LLVMFuzzerInitialize:
   34|      1|extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) {
   35|      1|  g_processor = std::make_unique<sentencepiece::SentencePieceProcessor>();
   36|       |
   37|       |  // Load the model from the embedded byte array
   38|      1|  std::string model_data(
   39|      1|      reinterpret_cast<const char *>(kEmbeddedModelData),
   40|      1|      kEmbeddedModelSize);
   41|      1|  auto status = g_processor->LoadFromSerializedProto(model_data);
   42|      1|  if (!status.ok()) {
  ------------------
  |  Branch (42:7): [True: 0, False: 1]
  ------------------
   43|      0|    fprintf(stderr, "Failed to load embedded model: %s\n",
   44|      0|            status.ToString().c_str());
   45|      0|    abort();
   46|      0|  }
   47|       |
   48|      1|  return 0;
   49|      1|}

_ZN4absl12lts_2026081713little_endian10FromHost64Em:
  109|     11|inline uint64_t FromHost64(uint64_t x) { return x; }
_ZN4absl12lts_2026081713little_endian6Load64EPKv:
  176|      5|inline uint64_t Load64(const void* absl_nonnull p) {
  177|      5|  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
  ------------------
  |  |   78|      5|  (absl::base_internal::UnalignedLoad64(_p))
  ------------------
  178|      5|}
_ZN4absl12lts_2026081713little_endian7Store64EPvm:
  180|     11|inline void Store64(void* absl_nonnull p, uint64_t v) {
  181|     11|  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
  ------------------
  |  |   85|     11|  (absl::base_internal::UnalignedStore64(_p, _val))
  ------------------
  182|     11|}

_ZN4absl12lts_2026081713base_internal16UnalignedStore64EPvm:
   65|     11|inline void UnalignedStore64(void* absl_nonnull p, uint64_t v) {
   66|     11|  memcpy(p, &v, sizeof v);
   67|     11|}

_ZN4absl12lts_2026081728PrefetchToLocalCacheForWriteEPKv:
  156|      3|    const void* addr) {
  157|       |  // [x86] gcc/clang don't generate PREFETCHW for __builtin_prefetch(.., 1)
  158|       |  // unless -march=broadwell or newer; this is not generally the default, so we
  159|       |  // manually emit prefetchw. PREFETCHW is recognized as a no-op on older Intel
  160|       |  // processors and has been present on AMD processors since the K6-2.
  161|      3|#if defined(__x86_64__) && !defined(__PRFCHW__)
  162|      3|  asm("prefetchw %0" : : "m"(*reinterpret_cast<const char*>(addr)));
  163|       |#else
  164|       |  __builtin_prefetch(addr, 1, 3);
  165|       |#endif
  166|      3|}

_ZN4absl12lts_2026081718container_internal8AllocateILm8ENSt3__19allocatorIcEEEEPvPT0_m:
   62|     11|void* Allocate(Alloc* alloc, size_t n) {
   63|     11|  static_assert(Alignment > 0, "");
   64|     11|  assert(n && "n must be positive");
   65|     11|  using M = AlignedType<Alignment>;
   66|     11|  using A = typename std::allocator_traits<Alloc>::template rebind_alloc<M>;
   67|     11|  using AT = typename std::allocator_traits<Alloc>::template rebind_traits<M>;
   68|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   69|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   70|       |  // with the "foo(bar)" syntax.
   71|     11|  A my_mem_alloc(*alloc);
   72|     11|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   73|       |  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   74|     11|         "allocator does not respect alignment");
   75|     11|  return p;
   76|     11|}
_ZN4absl12lts_2026081718container_internal10DeallocateILm8ENSt3__19allocatorIcEEEEvPT0_Pvm:
   93|      8|void Deallocate(Alloc* alloc, void* p, size_t n) {
   94|      8|  static_assert(Alignment > 0, "");
   95|      8|  assert(n && "n must be positive");
   96|      8|  using M = AlignedType<Alignment>;
   97|      8|  using A = typename std::allocator_traits<Alloc>::template rebind_alloc<M>;
   98|      8|  using AT = typename std::allocator_traits<Alloc>::template rebind_traits<M>;
   99|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
  100|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
  101|       |  // with the "foo(bar)" syntax.
  102|      8|  A my_mem_alloc(*alloc);
  103|      8|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
  104|      8|                 (n + sizeof(M) - 1) / sizeof(M));
  105|      8|}

_ZNK4absl12lts_2026081718container_internal13GroupSse2Impl18MaskEmptyOrDeletedEv:
  318|      5|  NonIterableBitMaskType MaskEmptyOrDeleted() const {
  319|      5|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  320|      5|    return NonIterableBitMaskType(
  321|      5|        MoveMask(_mm_cmpgt_epi8_fixed(special, ctrl)));
  322|      5|  }
_ZN4absl12lts_2026081718container_internal7IsEmptyENS1_6ctrl_tE:
  222|      2|inline bool IsEmpty(ctrl_t c) { return c == ctrl_t::kEmpty; }
_ZN4absl12lts_2026081718container_internal6IsFullENS1_6ctrl_tE:
  223|    555|inline bool IsFull(ctrl_t c) {
  224|       |  // Cast `c` to the underlying type instead of casting `0` to `ctrl_t` as `0`
  225|       |  // is not a value in the enum. Both ways are equivalent, but this way makes
  226|       |  // linters happier.
  227|    555|  return static_cast<std::underlying_type_t<ctrl_t>>(c) >= 0;
  228|    555|}
_ZN4absl12lts_2026081718container_internal20_mm_cmpgt_epi8_fixedEDv2_xS2_:
  266|      5|inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
  267|       |#if defined(__GNUC__) && !defined(__clang__)
  268|       |  if (std::is_unsigned_v<char>) {
  269|       |    const __m128i mask = _mm_set1_epi8(0x80);
  270|       |    const __m128i diff = _mm_subs_epi8(b, a);
  271|       |    return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
  272|       |  }
  273|       |#endif
  274|      5|  return _mm_cmpgt_epi8(a, b);
  275|      5|}

_ZNK4absl12lts_2026081718container_internal20HashtablezInfoHandle9IsSampledEv:
  204|     11|  inline bool IsSampled() const { return false; }
_ZN4absl12lts_2026081718container_internal20HashtablezInfoHandle20RecordStorageChangedEmm:
  205|      1|  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
_ZN4absl12lts_2026081718container_internal20HashtablezInfoHandle17RecordReservationEm:
  207|      2|  inline void RecordReservation(size_t /*target_capacity*/) {}
_ZN4absl12lts_2026081718container_internal20HashtablezInfoHandle16RecordInsertMissEmm:
  210|    545|                               size_t /*distance_from_desired*/) {}
_ZN4absl12lts_2026081718container_internal21ShouldSampleNextTableEv:
  226|      3|inline bool ShouldSampleNextTable() {
  227|       |#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
  228|       |  if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0)) {
  229|       |    return false;
  230|       |  }
  231|       |  return true;
  232|       |#else
  233|      3|  return false;
  234|      3|#endif  // ABSL_INTERNAL_HASHTABLEZ_SAMPLE
  235|      3|}

_ZN4absl12lts_2026081718container_internal5ClearILb0EEEvRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPFvPvS8_ES8_:
  929|      3|           DestroySlotFn destroy_slot, void* alloc) {
  930|      3|  if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (930:7): [Folded, False: 3]
  |  Branch (930:7): [Folded, False: 3]
  ------------------
  931|      0|      c.maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (931:7): [True: 0, False: 0]
  ------------------
  932|      0|    c.set_capacity(policy.soo_capacity());
  933|      0|  }
  934|      3|  c.AssertNotDebugCapacity();
  935|      3|  const size_t cap = c.capacity();
  936|       |  if constexpr (kSooEnabled) {
  937|       |    ABSL_ASSUME(cap > 0);
  938|       |  }
  939|      3|  if (c.is_small()) {
  ------------------
  |  Branch (939:7): [True: 2, False: 1]
  ------------------
  940|      2|    if (!c.empty()) {
  ------------------
  |  Branch (940:9): [True: 0, False: 2]
  ------------------
  941|      0|      if (destroy_slot != nullptr) {
  ------------------
  |  Branch (941:11): [True: 0, False: 0]
  ------------------
  942|      0|        destroy_slot(&c, SingleSlotAddress<kSooEnabled>(c));
  943|      0|      }
  944|      0|      DecrementSmallSize<kSooEnabled>(c);
  945|      0|      c.infoz().RecordStorageChanged(0, cap);
  946|      0|    }
  947|      2|  } else {
  948|      1|    if (destroy_slot != nullptr) {
  ------------------
  |  Branch (948:9): [True: 0, False: 1]
  ------------------
  949|      0|      DestroySlots(c, policy.slot_size, destroy_slot);
  950|      0|    }
  951|       |    // Iterating over this container is O(bucket_count()). When bucket_count()
  952|       |    // is much greater than size(), iteration becomes prohibitively expensive.
  953|       |    // For clear() it is more important to reuse the allocated array when the
  954|       |    // container is small because allocation takes comparatively long time
  955|       |    // compared to destruction of the elements of the container. So we pick the
  956|       |    // largest bucket_count() threshold for which iteration is still fast and
  957|       |    // past that we simply deallocate the array.
  958|      1|    ClearBackingArray(c, policy, alloc, /*reuse=*/cap < 128);
  959|      1|  }
  960|      3|  c.set_reserved_growth(0);
  961|      3|  c.set_reservation_size(0);
  962|      3|}
_ZN4absl12lts_2026081718container_internal17NextHashTableSeedEv:
  144|      3|uint8_t NextHashTableSeed() {
  145|      3|  return static_cast<uint8_t>(RandomSeed());
  146|      3|}
_ZN4absl12lts_2026081718container_internal18GrowthInfoAccessor23InitGrowthLeftNoDeletedEmm:
  361|     11|                                                 size_t capacity) {
  362|     11|  if (capacity <= GrowthInfoLowerBound::kMaxGrowthLeftLowerBound) {
  ------------------
  |  Branch (362:7): [True: 8, False: 3]
  ------------------
  363|      8|    *growth_info_lower_bound_ = static_cast<uint8_t>(growth_left);
  364|      8|  } else {
  365|      3|    uint64_t lower_bound =
  366|      3|        (std::min)(uint64_t{growth_left},
  367|      3|                   GrowthInfoLowerBound::kMaxGrowthLeftLowerBound);
  368|      3|    little_endian::Store64(
  369|      3|        full_growth_info_ptr(),
  370|      3|        GetPackedIncrement(lower_bound, growth_left - lower_bound));
  371|      3|  }
  372|     11|}
_ZN4absl12lts_2026081718container_internal18GrowthInfoAccessor29RebalanceGrowthLeftLowerBoundEm:
  375|      9|    size_t capacity) {
  376|      9|  auto growth_left_lower_bound = GetGrowthInfoLowerBound();
  377|      9|  if (capacity <= GrowthInfoLowerBound::kMaxGrowthLeftLowerBound ||
  ------------------
  |  Branch (377:7): [True: 6, False: 3]
  ------------------
  378|       |      // For tables with deleted slots, we often call rebalance even if
  379|       |      // we have growth left in the lower bound.
  380|      6|      growth_left_lower_bound.HasDeletedAndGrowthLeft()) {
  ------------------
  |  Branch (380:7): [True: 0, False: 3]
  ------------------
  381|      6|    return growth_left_lower_bound;
  382|      6|  } else {
  383|      3|    return RebalanceGrowthLeftLowerBoundLargeCapacity();
  384|      3|  }
  385|      9|}
_ZN4absl12lts_2026081718container_internal18GrowthInfoAccessor42RebalanceGrowthLeftLowerBoundLargeCapacityEv:
  397|      3|GrowthInfoAccessor::RebalanceGrowthLeftLowerBoundLargeCapacity() {
  398|      3|  void* full_growth_info = full_growth_info_ptr();
  399|      3|  uint64_t packed_full_growth_info = little_endian::Load64(full_growth_info);
  400|      3|  uint64_t overflow_growth_left =
  401|      3|      GetOverflowGrowthLeftFromPacked(packed_full_growth_info);
  402|      3|  uint64_t lower_bound_growth_left =
  403|      3|      GetGrowthLeftLowerBoundFromPacked(packed_full_growth_info);
  404|      3|  uint64_t overflow_to_lower_bound_size =
  405|      3|      (std::min)(overflow_growth_left,
  406|      3|                 GrowthInfoLowerBound::kMaxGrowthLeftLowerBound -
  407|      3|                     lower_bound_growth_left);
  408|      3|  packed_full_growth_info +=
  409|      3|      GetRebalanceIncrement(overflow_to_lower_bound_size);
  410|      3|  little_endian::Store64(full_growth_info, packed_full_growth_info);
  411|      3|  auto result = GetGrowthInfoLowerBoundFromPacked(packed_full_growth_info);
  412|      3|  ABSL_SWISSTABLE_ASSERT(result.HasNoDeleted() ==
  ------------------
  |  |   66|      3|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  413|      3|                         GetGrowthInfoLowerBound().HasNoDeleted());
  414|       |  ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |   66|      3|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  415|      3|      (result.GetGrowthLeft() > 0 ||
  416|      3|       GetGrowthLeftTotalBigCapacity(full_growth_info_ptr()) == 0) &&
  417|      3|      "rebalance may return 0 only if we have absolutely no growth left");
  418|      3|  return result;
  419|      3|}
_ZN4absl12lts_2026081718container_internal17ClearBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPvb:
  887|      1|                       bool reuse) {
  888|      1|  ABSL_SWISSTABLE_ASSERT(c.capacity() > kMaxSmallCapacity);
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  889|      1|  if (reuse) {
  ------------------
  |  Branch (889:7): [True: 1, False: 0]
  ------------------
  890|      1|    const size_t blocked_element_count = c.blocked_element_count();
  891|      1|    c.set_size_to_zero();
  892|      1|    ABSL_SWISSTABLE_ASSERT(c.capacity() > policy.soo_capacity());
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  893|      1|    ResetCtrl(c, policy.slot_size, blocked_element_count);
  894|      1|    ResetGrowthLeft(c.growth_info(), c.capacity(), blocked_element_count);
  895|      1|    ABSL_SWISSTABLE_ASSERT(c.blocked_element_count() == blocked_element_count);
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  896|      1|    c.infoz().RecordStorageChanged(0, c.capacity());
  897|      1|  } else {
  898|      0|    ClearBackingArrayNoReuse(c, policy, alloc);
  899|      0|  }
  900|      1|}
_ZN4absl12lts_2026081718container_internal24PrepareInsertSmallNonSooERNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEE:
 1855|      2|                               absl::FunctionRef<size_t(size_t)> get_hash) {
 1856|      2|  ABSL_SWISSTABLE_ASSERT(common.is_small());
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1857|      2|  ABSL_SWISSTABLE_ASSERT(!policy.soo_enabled);
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1858|      2|  if (common.capacity() == 1) {
  ------------------
  |  Branch (1858:7): [True: 1, False: 1]
  ------------------
 1859|      1|    if (common.empty()) {
  ------------------
  |  Branch (1859:9): [True: 0, False: 1]
  ------------------
 1860|      0|      IncrementSmallSizeNonSoo(common, policy);
 1861|      0|      if (common.has_infoz()) {
  ------------------
  |  Branch (1861:11): [True: 0, False: 0]
  ------------------
 1862|      0|        common.infoz().RecordInsertMiss(get_hash(common.seed().seed()),
 1863|      0|                                        /*distance_from_desired=*/0);
 1864|      0|      }
 1865|      0|      return common.slot_array(/*capacity=*/1);
 1866|      1|    } else {
 1867|      1|      return Grow1To3AndPrepareInsert(common, policy, get_hash);
 1868|      1|    }
 1869|      1|  }
 1870|       |
 1871|       |  // Growing from 0 to 1 capacity.
 1872|      1|  ABSL_SWISSTABLE_ASSERT(common.capacity() == 0);
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1873|      1|  constexpr size_t kNewCapacity = 1;
 1874|       |
 1875|      1|  common.set_capacity(kNewCapacity);
 1876|      1|  HashtablezInfoHandle infoz;
 1877|      1|  const bool should_sample =
 1878|      1|      policy.is_hashtablez_eligible && ShouldSampleNextTable();
  ------------------
  |  Branch (1878:7): [True: 1, False: 0]
  |  Branch (1878:40): [True: 0, False: 1]
  ------------------
 1879|      1|  if (ABSL_PREDICT_FALSE(should_sample)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1880|      0|    infoz = ForcedTrySample(policy.slot_size, policy.key_size,
 1881|      0|                            policy.value_size, policy.soo_capacity());
 1882|      0|  }
 1883|      1|  const bool has_infoz = infoz.IsSampled();
 1884|      1|  void* alloc = policy.get_char_alloc(common);
 1885|       |
 1886|      1|  const auto [new_ctrl, new_slots] =
 1887|      1|      AllocBackingArray(common, policy, kNewCapacity, has_infoz, alloc,
 1888|      1|                        /*blocked_element_count=*/0);
 1889|      1|  common.set_control(new_ctrl);
 1890|       |
 1891|      1|  static_assert(NextCapacity(0) == 1);
 1892|      1|  PrepareInsertCommon(common);
 1893|       |
 1894|      1|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1895|      0|    common.generate_new_seed(/*has_infoz=*/true);
 1896|      0|    ReportSingleGroupTableGrowthToInfoz(common, infoz,
 1897|      0|                                        get_hash(common.seed().seed()));
 1898|      0|  }
 1899|      1|  return new_slots;
 1900|      2|}
_ZN4absl12lts_2026081718container_internal19GetRefForEmptyClassERNS1_12CommonFieldsE:
 2096|     12|void* GetRefForEmptyClass(CommonFields& common) {
 2097|       |  // Empty base optimization typically make the empty base class address to be
 2098|       |  // the same as the first address of the derived class object.
 2099|       |  // But we generally assume that for empty classes we can return any valid
 2100|       |  // pointer.
 2101|     12|  return &common;
 2102|     12|}
_ZN4absl12lts_2026081718container_internal24ReserveTableToFitNewSizeERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 2346|      2|                              size_t new_size) {
 2347|      2|  new_size =
 2348|      2|      std::min(new_size, MaxValidSize(policy.key_size, policy.slot_size));
 2349|      2|  common.reset_reserved_growth(new_size);
 2350|      2|  common.set_reservation_size(new_size);
 2351|      2|  ABSL_SWISSTABLE_ASSERT(new_size > policy.soo_capacity());
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2352|      2|  const size_t cap = common.capacity();
 2353|      2|  if (ABSL_PREDICT_TRUE(common.empty() && cap <= policy.soo_capacity())) {
  ------------------
  |  |  191|      4|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 2, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 2]
  |  |  |  Branch (191:58): [True: 2, False: 0]
  |  |  |  Branch (191:58): [True: 2, False: 0]
  |  |  ------------------
  ------------------
 2354|      2|    return ReserveEmptyNonAllocatedTableToFitNewSize(common, policy, new_size);
 2355|      2|  }
 2356|       |
 2357|      0|  ABSL_SWISSTABLE_ASSERT(!common.empty() || cap > policy.soo_capacity());
  ------------------
  |  |   66|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2358|      0|  ABSL_SWISSTABLE_ASSERT(cap > 0);
  ------------------
  |  |   66|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2359|      0|  const size_t max_size_before_growth =
 2360|      0|      IsSmallCapacity(cap)
  ------------------
  |  Branch (2360:7): [True: 0, False: 0]
  ------------------
 2361|      0|          ? cap
 2362|      0|          : common.size() + common.growth_info().GetGrowthLeftTotalSlow(cap);
 2363|      0|  if (new_size <= max_size_before_growth) {
  ------------------
  |  Branch (2363:7): [True: 0, False: 0]
  ------------------
 2364|      0|    return;
 2365|      0|  }
 2366|      0|  ReserveAllocatedTable(common, policy, new_size);
 2367|      0|}
_ZN4absl12lts_2026081718container_internal18PrepareInsertLargeERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_18NonIterableBitMaskIjLi16ELi0EEENS1_8FindInfoE:
 2400|    552|                         FindInfo target_group) {
 2401|       |  // NOLINTNEXTLINE(misc-static-assert)
 2402|       |  ABSL_SWISSTABLE_ASSERT(!SwisstableGenerationsEnabled());
  ------------------
  |  |   66|    552|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2403|    552|  return PrepareInsertLargeImpl(common, policy, hash, mask_empty, target_group);
 2404|    552|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_119Resize1To3NewOffsetEmNS1_12PerTableSeedE:
  113|      1|size_t Resize1To3NewOffset(size_t hash, PerTableSeed seed) {
  114|       |  // After resize from capacity 1 to 3, we always have exactly the slot with
  115|       |  // index 1 occupied, so we need to insert either at index 0 or index 2.
  116|      1|  static_assert(SooSlotIndex() == 1);
  117|      1|  return SingleGroupTableH1(hash, seed) & 2;
  118|      1|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_118SingleGroupTableH1EmNS1_12PerTableSeedE:
  108|      3|size_t SingleGroupTableH1(size_t hash, PerTableSeed seed) {
  109|      3|  return hash ^ seed.seed();
  110|      3|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_111SlotAddressEPvmm:
  122|    559|inline void* SlotAddress(void* slot_array, size_t slot, size_t slot_size) {
  123|    559|  return static_cast<void*>(static_cast<char*>(slot_array) +
  124|    559|                            (slot * slot_size));
  125|    559|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_110RandomSeedEv:
   81|      3|inline size_t RandomSeed() {
   82|      3|  constexpr size_t kIncrement = 0xad53;
   83|      3|#ifdef ABSL_HAVE_THREAD_LOCAL
   84|      3|  static thread_local size_t counter = 0;
   85|      3|  counter += kIncrement;
   86|      3|  size_t value = counter;
   87|       |#else   // ABSL_HAVE_THREAD_LOCAL
   88|       |  static std::atomic<size_t> counter(0);
   89|       |  size_t value = counter.fetch_add(kIncrement, std::memory_order_relaxed);
   90|       |#endif  // ABSL_HAVE_THREAD_LOCAL
   91|      3|  return value ^ static_cast<size_t>(reinterpret_cast<uintptr_t>(&counter));
   92|      3|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_118GetPackedIncrementEmm:
  292|      6|                                      uint64_t overflow_increment) {
  293|      6|  return (lower_bound_increment << GrowthInfoAccessor::kLowerBoundShift) +
  294|      6|         overflow_increment;
  295|      6|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_131GetOverflowGrowthLeftFromPackedEm:
  308|      3|    uint64_t packed_full_growth_info) {
  309|      3|  constexpr uint64_t kFullGrowthMask =
  310|      3|      (uint64_t{1} << GrowthInfoAccessor::kLowerBoundShift) - 1;
  311|      3|  return packed_full_growth_info & kFullGrowthMask;
  312|      3|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_133GetGrowthLeftLowerBoundFromPackedEm:
  324|      3|    uint64_t packed_full_growth_info) {
  325|      3|  return GetGrowthInfoLowerBoundFromPacked(packed_full_growth_info)
  326|      3|      .GetGrowthLeft();
  327|      3|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_121GetRebalanceIncrementEm:
  301|      3|    uint64_t overflow_to_lower_bound_size) {
  302|      3|  return GetPackedIncrement(overflow_to_lower_bound_size,
  303|      3|                            0u - overflow_to_lower_bound_size);
  304|      3|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_133GetGrowthInfoLowerBoundFromPackedEm:
  317|      6|    uint64_t packed_full_growth_info) {
  318|      6|  return GrowthInfoLowerBound(packed_full_growth_info >>
  319|      6|                              GrowthInfoAccessor::kLowerBoundShift);
  320|      6|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_119PrepareInsertCommonERNS1_12CommonFieldsE:
  500|    554|void PrepareInsertCommon(CommonFields& common) {
  501|    554|  common.increment_size();
  502|    554|  common.maybe_increment_generation_on_insert();
  503|    554|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_135InitializeThreeElementsControlBytesEhhmPNS1_6ctrl_tE:
  759|      1|    h2_t orig_h2, h2_t new_h2, size_t new_offset, ctrl_t* new_ctrl) {
  760|      1|  static constexpr size_t kNewCapacity = NextCapacity(SooCapacity());
  761|      1|  static_assert(kNewCapacity == 3);
  762|      1|  static_assert(is_single_group(kNewCapacity));
  763|      1|  static_assert(SooSlotIndex() == 1);
  764|      1|  ABSL_SWISSTABLE_ASSERT(new_offset == 0 || new_offset == 2);
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  765|       |
  766|      1|  static constexpr uint64_t kEmptyXorSentinel =
  767|      1|      static_cast<uint8_t>(ctrl_t::kEmpty) ^
  768|      1|      static_cast<uint8_t>(ctrl_t::kSentinel);
  769|      1|  static constexpr uint64_t kEmpty64 = static_cast<uint8_t>(ctrl_t::kEmpty);
  770|      1|  static constexpr size_t kMirroredSooSlotIndex =
  771|      1|      SooSlotIndex() + kNewCapacity + 1;
  772|       |  // The first 8 bytes, where SOO slot original and mirrored positions are
  773|       |  // replaced with 0.
  774|       |  // Result will look like: E0ESE0EE
  775|      1|  static constexpr uint64_t kFirstCtrlBytesWithZeroes =
  776|      1|      k8EmptyBytes ^ (kEmpty64 << (8 * SooSlotIndex())) ^
  777|      1|      (kEmptyXorSentinel << (8 * kNewCapacity)) ^
  778|      1|      (kEmpty64 << (8 * kMirroredSooSlotIndex));
  779|       |
  780|      1|  const uint64_t soo_h2 = static_cast<uint64_t>(orig_h2);
  781|      1|  const uint64_t new_h2_xor_empty =
  782|      1|      static_cast<uint64_t>(new_h2 ^ static_cast<uint8_t>(ctrl_t::kEmpty));
  783|       |  // Fill the original and mirrored bytes for SOO slot.
  784|       |  // Result will look like:
  785|       |  // EHESEHEE
  786|       |  // Where H = soo_h2, E = kEmpty, S = kSentinel.
  787|      1|  uint64_t first_ctrl_bytes =
  788|      1|      ((soo_h2 << (8 * SooSlotIndex())) | kFirstCtrlBytesWithZeroes) |
  789|      1|      (soo_h2 << (8 * kMirroredSooSlotIndex));
  790|       |  // Replace original and mirrored empty bytes for the new position.
  791|       |  // Result for new_offset 0 will look like:
  792|       |  // NHESNHEE
  793|       |  // Where H = soo_h2, N = H2(new_hash), E = kEmpty, S = kSentinel.
  794|       |  // Result for new_offset 2 will look like:
  795|       |  // EHNSEHNE
  796|      1|  first_ctrl_bytes ^= (new_h2_xor_empty << (8 * new_offset));
  797|      1|  size_t new_mirrored_offset = new_offset + kNewCapacity + 1;
  798|      1|  first_ctrl_bytes ^= (new_h2_xor_empty << (8 * new_mirrored_offset));
  799|       |
  800|       |  // Fill last bytes with kEmpty.
  801|      1|  std::memset(new_ctrl + kNewCapacity, static_cast<int8_t>(ctrl_t::kEmpty),
  802|      1|              Group::kWidth);
  803|       |  // Overwrite the first 8 bytes with first_ctrl_bytes.
  804|      1|  absl::little_endian::Store64(new_ctrl, first_ctrl_bytes);
  805|       |
  806|       |  // Example for group size 16:
  807|       |  // new_ctrl after 1st memset =      ???EEEEEEEEEEEEEEEE
  808|       |  // new_offset 0:
  809|       |  // new_ctrl after 2nd store  =      NHESNHEEEEEEEEEEEEE
  810|       |  // new_offset 2:
  811|       |  // new_ctrl after 2nd store  =      EHNSEHNEEEEEEEEEEEE
  812|       |
  813|       |  // Example for group size 8:
  814|       |  // new_ctrl after 1st memset =      ???EEEEEEEE
  815|       |  // new_offset 0:
  816|       |  // new_ctrl after 2nd store  =      NHESNHEEEEE
  817|       |  // new_offset 2:
  818|       |  // new_ctrl after 2nd store  =      EHNSEHNEEEE
  819|      1|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_17SetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  532|    543|                    size_t slot_size) {
  533|       |  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   66|    543|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  534|    543|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  535|    543|  SetCtrlNoSanitizeImpl(c, i, h);
  536|    543|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_119DoSanitizeOnSetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  507|    555|                                size_t slot_size) {
  508|    555|  const size_t cap = c.capacity();
  509|    555|  ABSL_ASSUME(cap > kMaxSmallCapacity);
  ------------------
  |  |  272|    555|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  510|    555|  ABSL_SWISSTABLE_ASSERT(i < cap);
  ------------------
  |  |   66|    555|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  511|    555|  auto* slot_i = static_cast<const char*>(c.slot_array(cap)) + i * slot_size;
  512|    555|  if (IsFull(h)) {
  ------------------
  |  Branch (512:7): [True: 555, False: 0]
  ------------------
  513|    555|    SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
  514|    555|  } else {
  515|      0|    SanitizerPoisonMemoryRegion(slot_i, slot_size);
  516|      0|  }
  517|    555|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_121SetCtrlNoSanitizeImplERKNS1_12CommonFieldsEmNS1_6ctrl_tE:
  523|    558|inline void SetCtrlNoSanitizeImpl(const CommonFields& c, size_t i, ctrl_t h) {
  524|       |  ABSL_SWISSTABLE_ASSERT(i < c.capacity());
  ------------------
  |  |   66|    558|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  525|    558|  ctrl_t* ctrl = c.control();
  526|    558|  const size_t cap = c.capacity();
  527|    558|  ctrl[i] = h;
  528|    558|  ctrl[((i - NumClonedBytes()) & cap) + (NumClonedBytes() & cap)] = h;
  529|    558|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_119SetCtrlInLargeTableERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  572|     10|                                size_t slot_size) {
  573|       |  ABSL_SWISSTABLE_ASSERT(c.capacity() >= Group::kWidth - 1);
  ------------------
  |  |   66|     10|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  574|     10|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  575|     10|  ctrl_t* ctrl = c.control();
  576|     10|  ctrl[i] = h;
  577|     10|  ctrl[((i - NumClonedBytes()) & c.capacity()) + NumClonedBytes()] = h;
  578|     10|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_19ResetCtrlERNS1_12CommonFieldsEmm:
  730|      3|               size_t blocked_element_count) {
  731|      3|  ABSL_SWISSTABLE_ASSERT(IsCapacityValidForBlockedElements(common.capacity()) ||
  ------------------
  |  |   66|      3|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  732|      3|                         blocked_element_count == 0);
  733|      3|  const size_t capacity = common.capacity();
  734|      3|  ctrl_t* ctrl = common.control();
  735|      3|  static constexpr size_t kTwoGroupCapacity = 2 * Group::kWidth - 1;
  736|      3|  if (ABSL_PREDICT_TRUE(capacity <= kTwoGroupCapacity)) {
  ------------------
  |  |  191|      3|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 3]
  |  |  |  Branch (191:48): [Folded, False: 3]
  |  |  |  Branch (191:57): [True: 0, False: 3]
  |  |  ------------------
  ------------------
  737|      0|    if (IsSmallCapacity(capacity)) return;
  ------------------
  |  Branch (737:9): [True: 0, False: 0]
  ------------------
  738|      0|    std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
  739|      0|    std::memset(ctrl + capacity, static_cast<int8_t>(ctrl_t::kEmpty),
  740|      0|                Group::kWidth);
  741|      0|    if (capacity == kTwoGroupCapacity) {
  ------------------
  |  Branch (741:9): [True: 0, False: 0]
  ------------------
  742|      0|      std::memset(ctrl + Group::kWidth, static_cast<int8_t>(ctrl_t::kEmpty),
  743|      0|                  Group::kWidth);
  744|      0|    }
  745|      3|  } else {
  746|      3|    std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty),
  747|      3|                capacity + 1 + NumClonedBytes());
  748|      3|  }
  749|      3|  ctrl[capacity] = ctrl_t::kSentinel;
  750|      3|  SanitizerPoisonMemoryRegion(common.slot_array(capacity),
  751|      3|                              slot_size * (capacity - blocked_element_count));
  752|      3|  BlockControlBytes(common, blocked_element_count);
  753|      3|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_117BlockControlBytesERNS1_12CommonFieldsEm:
  585|      3|void BlockControlBytes(CommonFields& common, size_t blocked_element_count) {
  586|      3|  const size_t capacity = common.capacity();
  587|     18|  while (blocked_element_count > 0) {
  ------------------
  |  Branch (587:10): [True: 15, False: 3]
  ------------------
  588|     15|    BlockCtrl(common, capacity - blocked_element_count);
  589|     15|    --blocked_element_count;
  590|     15|  }
  591|      3|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_19BlockCtrlERKNS1_12CommonFieldsEm:
  546|     15|inline void BlockCtrl(const CommonFields& c, size_t i) {
  547|       |  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   66|     15|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  548|     15|  SetCtrlNoSanitizeImpl(c, i, ctrl_t::kSentinel);
  549|     15|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_115ResetGrowthLeftENS1_18GrowthInfoAccessorEmm:
  470|     10|                     size_t occupied_elements) {
  471|     10|  growth_info.InitGrowthLeftNoDeleted(
  472|     10|      CapacityToGrowth(capacity) - occupied_elements, capacity);
  473|     10|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_117AllocBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmbPvm:
 1085|     11|                                   void* alloc, size_t blocked_element_count) {
 1086|     11|  RawHashSetLayout layout(new_capacity, policy.slot_size, policy.slot_align,
 1087|     11|                          has_infoz, blocked_element_count);
 1088|       |  // Perform a direct call in the common case to allow for profile-guided
 1089|       |  // heap optimization (PGHO) to understand which allocation function is used.
 1090|     11|  constexpr size_t kDefaultAlignment = BackingArrayAlignment(alignof(size_t));
 1091|     11|  char* mem = static_cast<char*>(
 1092|     11|      ABSL_PREDICT_TRUE(
  ------------------
  |  |  191|     11|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 11, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 11]
  |  |  |  Branch (191:57): [True: 11, False: 0]
  |  |  ------------------
  ------------------
 1093|     11|          policy.alloc ==
 1094|     11|          (&AllocateBackingArray<kDefaultAlignment, std::allocator<char>>))
 1095|     11|          ? AllocateBackingArray<kDefaultAlignment, std::allocator<char>>(
 1096|     11|                alloc, layout.alloc_size())
 1097|     11|          : policy.alloc(alloc, layout.alloc_size()));
 1098|     11|  const GenerationType old_generation = common.generation();
 1099|     11|  common.set_generation_ptr(
 1100|     11|      reinterpret_cast<GenerationType*>(mem + layout.generation_offset()));
 1101|     11|  common.set_generation(NextGeneration(old_generation));
 1102|       |
 1103|     11|  return {reinterpret_cast<ctrl_t*>(mem + layout.control_offset()),
 1104|     11|          mem + layout.slot_offset()};
 1105|     11|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_124Grow1To3AndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEE:
 1717|      1|                               absl::FunctionRef<size_t(size_t)> get_hash) {
 1718|       |  // TODO(b/413062340): Refactor to reuse more code with
 1719|       |  // GrowSooTableToNextCapacityAndPrepareInsert.
 1720|      1|  ABSL_SWISSTABLE_ASSERT(common.capacity() == 1);
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1721|      1|  ABSL_SWISSTABLE_ASSERT(!common.empty());
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1722|      1|  ABSL_SWISSTABLE_ASSERT(!policy.soo_enabled);
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1723|       |  // 1-element tables can't have any blocked elements.
 1724|      1|  ABSL_SWISSTABLE_ASSERT(common.blocked_element_count() == 0);
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1725|      1|  constexpr size_t kOldCapacity = 1;
 1726|      1|  constexpr size_t kNewCapacity = NextCapacity(kOldCapacity);
 1727|      1|  void* old_slots = common.slot_array(kOldCapacity);
 1728|       |
 1729|      1|  const size_t slot_size = policy.slot_size;
 1730|      1|  const size_t slot_align = policy.slot_align;
 1731|      1|  void* alloc = policy.get_char_alloc(common);
 1732|      1|  HashtablezInfoHandle infoz = common.infoz();
 1733|      1|  const bool has_infoz = infoz.IsSampled();
 1734|      1|  common.set_capacity(kNewCapacity);
 1735|       |
 1736|      1|  const auto [new_ctrl, new_slots] =
 1737|      1|      AllocBackingArray(common, policy, kNewCapacity, has_infoz, alloc,
 1738|      1|                        /*blocked_element_count=*/0);
 1739|      1|  common.set_control(new_ctrl);
 1740|      1|  SanitizerPoisonMemoryRegion(new_slots, kNewCapacity * slot_size);
 1741|       |
 1742|      1|  if (ABSL_PREDICT_TRUE(!has_infoz)) {
  ------------------
  |  |  191|      1|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 1]
  |  |  |  Branch (191:57): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 1743|       |    // When we're sampled, we already have a seed.
 1744|      1|    common.generate_new_seed(/*has_infoz=*/false);
 1745|      1|  }
 1746|      1|  const size_t new_hash = get_hash(common.seed().seed());
 1747|      1|  h2_t new_h2 = H2(new_hash);
 1748|      1|  size_t orig_hash =
 1749|      1|      policy.hash_slot(policy.hash_fn(common), old_slots, common.seed().seed());
 1750|      1|  size_t offset = Resize1To3NewOffset(new_hash, common.seed());
 1751|      1|  InitializeThreeElementsControlBytes(H2(orig_hash), new_h2, offset, new_ctrl);
 1752|       |
 1753|      1|  void* old_element_target = NextSlot(new_slots, slot_size);
 1754|      1|  SanitizerUnpoisonMemoryRegion(old_element_target, slot_size);
 1755|      1|  policy.transfer_n(&common, old_element_target, old_slots, 1);
 1756|       |
 1757|      1|  void* new_element_target_slot = SlotAddress(new_slots, offset, slot_size);
 1758|      1|  SanitizerUnpoisonMemoryRegion(new_element_target_slot, slot_size);
 1759|       |
 1760|      1|  policy.dealloc(alloc, kOldCapacity,
 1761|       |                 // old_slots == old_ctrl in case of capacity == 1.
 1762|      1|                 static_cast<ctrl_t*>(old_slots),
 1763|      1|                 slot_size, slot_align, has_infoz,
 1764|      1|                 /*blocked_element_count=*/0);
 1765|      1|  PrepareInsertCommon(common);
 1766|      1|  ABSL_SWISSTABLE_ASSERT(common.size() == 2);
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1767|      1|  GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(kNewCapacity - 2,
 1768|      1|                                                             kNewCapacity);
 1769|       |
 1770|      1|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1771|      0|    ReportSingleGroupTableGrowthToInfoz(common, infoz, new_hash);
 1772|      0|  }
 1773|      1|  return new_element_target_slot;
 1774|      1|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_18NextSlotEPvmm:
  129|      3|inline void* NextSlot(void* slot, size_t slot_size, size_t i = 1) {
  130|      3|  return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(slot) +
  131|      3|                                 slot_size * i);
  132|      3|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_125SetCtrlInSingleGroupTableERKNS1_12CommonFieldsEmhm:
  565|      2|                                      size_t slot_size) {
  566|      2|  SetCtrlInSingleGroupTable(c, i, static_cast<ctrl_t>(h), slot_size);
  567|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_125SetCtrlInSingleGroupTableERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  554|      2|                                      size_t slot_size) {
  555|      2|  const size_t cap = c.capacity();
  556|      2|  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  557|       |  ABSL_SWISSTABLE_ASSERT(is_single_group(cap));
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  558|      2|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  559|      2|  ctrl_t* ctrl = c.control();
  560|      2|  ctrl[i] = h;
  561|      2|  ctrl[i + cap + 1] = h;
  562|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_119find_first_non_fullERKNS1_12CommonFieldsEm:
  207|      7|FindInfo find_first_non_full(const CommonFields& common, size_t hash) {
  208|      7|  return find_first_non_full_from_h1(common.control(), H1(hash),
  209|      7|                                     common.capacity_impl());
  210|      7|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_127find_first_non_full_from_h1EPKNS1_6ctrl_tEmNS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEE:
  190|     10|                                     HashtableCapacity capacity) {
  191|     10|  const size_t cap = capacity.capacity();
  192|     10|  auto seq = probe_h1(ProbeCapacity{cap}, h1);
  193|     10|  if (IsEmptyOrDeleted(ctrl[seq.offset()])) {
  ------------------
  |  Branch (193:7): [True: 5, False: 5]
  ------------------
  194|      5|    return {seq.offset(), /*probe_length=*/0};
  195|      5|  }
  196|      5|  auto mask = probe_till_first_non_full_group(ctrl, seq, cap);
  197|      5|  return {seq.offset(mask.LowestBitSet()), seq.index()};
  198|     10|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_131probe_till_first_non_full_groupEPKNS1_6ctrl_tERNS1_9probe_seqILm16EEEm:
  177|      5|    [[maybe_unused]] size_t capacity) {
  178|      5|  while (true) {
  ------------------
  |  Branch (178:10): [True: 5, Folded]
  ------------------
  179|      5|    GroupFullEmptyOrDeleted g{ctrl + seq.offset()};
  180|      5|    auto mask = g.MaskEmptyOrDeleted();
  181|      5|    if (mask) {
  ------------------
  |  Branch (181:9): [True: 5, False: 0]
  ------------------
  182|      5|      return mask;
  183|      5|    }
  184|      0|    seq.next();
  185|       |    ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity && "full table!");
  ------------------
  |  |   66|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  186|      0|  }
  187|      5|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_17SetCtrlERKNS1_12CommonFieldsEmhm:
  538|    543|inline void SetCtrl(const CommonFields& c, size_t i, h2_t h, size_t slot_size) {
  539|    543|  SetCtrl(c, i, static_cast<ctrl_t>(h), slot_size);
  540|    543|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_115ValidateMaxSizeEmmm:
   71|      2|                     [[maybe_unused]] size_t slot_size) {
   72|       |  ABSL_SWISSTABLE_ASSERT(size <= MaxValidSize(key_size, slot_size));
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
   73|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_132ResizeEmptyNonAllocatedTableImplERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmmb:
 1111|      2|                                      bool force_infoz) {
 1112|      2|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(new_capacity));
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1113|      2|  ABSL_SWISSTABLE_ASSERT(new_capacity > policy.soo_capacity());
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1114|      2|  ABSL_SWISSTABLE_ASSERT(!force_infoz || policy.soo_enabled);
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1115|      2|  ABSL_SWISSTABLE_ASSERT(common.capacity() == policy.soo_capacity());
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1116|      2|  ABSL_SWISSTABLE_ASSERT(common.empty());
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1117|      2|  const size_t slot_size = policy.slot_size;
 1118|      2|  HashtablezInfoHandle infoz;
 1119|      2|  const bool should_sample =
 1120|      2|      policy.is_hashtablez_eligible && (force_infoz || ShouldSampleNextTable());
  ------------------
  |  Branch (1120:7): [True: 2, False: 0]
  |  Branch (1120:41): [True: 0, False: 2]
  |  Branch (1120:56): [True: 0, False: 2]
  ------------------
 1121|      2|  if (ABSL_PREDICT_FALSE(should_sample)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 1122|      0|    infoz = ForcedTrySample(slot_size, policy.key_size, policy.value_size,
 1123|      0|                            policy.soo_capacity());
 1124|      0|  }
 1125|      2|  const bool has_infoz = infoz.IsSampled();
 1126|      2|  void* alloc = policy.get_char_alloc(common);
 1127|       |
 1128|      2|  common.set_capacity(new_capacity);
 1129|      2|  common.init_blocked_element_count(blocked_element_count);
 1130|      2|  const auto [new_ctrl, new_slots] = AllocBackingArray(
 1131|      2|      common, policy, new_capacity, has_infoz, alloc, blocked_element_count);
 1132|      2|  common.set_control(new_ctrl);
 1133|      2|  common.generate_new_seed(has_infoz);
 1134|       |
 1135|      2|  ResetCtrl(common, slot_size, blocked_element_count);
 1136|      2|  if (GrowthInfoSizeForCapacity(new_capacity) > 0) {
  ------------------
  |  Branch (1136:7): [True: 2, False: 0]
  ------------------
 1137|      2|    ResetGrowthLeft(GetGrowthInfoFromControl(new_ctrl), new_capacity,
 1138|      2|                    blocked_element_count);
 1139|      2|  }
 1140|       |
 1141|      2|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 1142|      0|    ReportResizeToInfoz(common, infoz, 0);
 1143|      0|  }
 1144|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_141ReserveEmptyNonAllocatedTableToFitNewSizeERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 2045|      2|    size_t new_size) {
 2046|      2|  ValidateMaxSize(new_size, policy.key_size, policy.slot_size);
 2047|      2|  ABSL_ASSUME(new_size > 0);
  ------------------
  |  |  272|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2048|      2|  const size_t new_capacity = SizeToCapacity(new_size);
 2049|      2|  ResizeEmptyNonAllocatedTableImpl(
 2050|      2|      common, policy, new_capacity,
 2051|      2|      BlockedElementCountForReservedTable(new_capacity, new_size),
 2052|      2|      /*force_infoz=*/false);
 2053|       |  // This is after resize, to ensure that we have completed the allocation
 2054|       |  // and have potentially sampled the hashtable.
 2055|      2|  common.infoz().RecordReservation(new_size);
 2056|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_135BlockedElementCountForReservedTableEmm:
 2025|      2|                                           size_t reserved_size) {
 2026|      2|  if (!IsCapacityValidForBlockedElements(capacity)) {
  ------------------
  |  Branch (2026:7): [True: 0, False: 2]
  ------------------
 2027|      0|    return 0;
 2028|      0|  }
 2029|      2|  const size_t blocked_elements = CapacityToGrowth(capacity) - reserved_size;
 2030|      2|  if (is_single_group(capacity)) {
  ------------------
  |  Branch (2030:7): [True: 0, False: 2]
  ------------------
 2031|       |    // Single group tables never probes, so we can block all the slots.
 2032|      0|    return blocked_elements;
 2033|      0|  }
 2034|      2|  return (std::min)(blocked_elements, kMaxBlockedElementsForLargeTables);
 2035|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_122PrepareInsertLargeImplERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_18NonIterableBitMaskIjLi16ELi0EEENS1_8FindInfoE:
 2374|    552|                             FindInfo target_group) {
 2375|    552|  ABSL_SWISSTABLE_ASSERT(!common.is_small());
  ------------------
  |  |   66|    552|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2376|    552|  GrowthInfoAccessor growth_info = common.growth_info();
 2377|       |  // When there are no deleted slots in the table
 2378|       |  // and growth_left is positive, we can insert at the first
 2379|       |  // empty slot in the probe sequence (target).
 2380|    552|  if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|    552|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 9, False: 543]
  |  |  |  Branch (190:49): [Folded, False: 552]
  |  |  |  Branch (190:58): [True: 9, False: 543]
  |  |  ------------------
  ------------------
 2381|    552|          !growth_info.GetGrowthInfoLowerBound().HasNoDeletedAndGrowthLeft())) {
 2382|      9|    return PrepareInsertLargeSlow(common, policy, hash);
 2383|      9|  }
 2384|    543|  PrepareInsertCommon(common);
 2385|    543|  growth_info.OverwriteEmptyAsFull();
 2386|    543|  const size_t cap = common.capacity();
 2387|    543|  ABSL_ASSUME(cap > kMaxSmallCapacity);
  ------------------
  |  |  272|    543|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2388|    543|  target_group.offset += mask_empty.LowestBitSet();
 2389|    543|  target_group.offset &= cap;
 2390|    543|  SetCtrl(common, target_group.offset, H2(hash), policy.slot_size);
 2391|    543|  common.infoz().RecordInsertMiss(hash, target_group.probe_length);
 2392|    543|  return SlotAddress(common.slot_array(cap), target_group.offset,
 2393|    543|                     policy.slot_size);
 2394|    552|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_122PrepareInsertLargeSlowERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1970|      9|                             size_t hash) {
 1971|      9|  GrowthInfoAccessor growth_info = common.growth_info();
 1972|      9|  const size_t cap = common.capacity();
 1973|      9|  ABSL_ASSUME(cap > kMaxSmallCapacity);
  ------------------
  |  |  272|      9|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1974|      9|  GrowthInfoLowerBound growth_info_lower_bound =
 1975|      9|      growth_info.RebalanceGrowthLeftLowerBound(cap);
 1976|      9|  if (ABSL_PREDICT_TRUE(
  ------------------
  |  |  191|      9|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 7, False: 2]
  |  |  |  Branch (191:48): [Folded, False: 9]
  |  |  |  Branch (191:57): [True: 7, False: 2]
  |  |  ------------------
  ------------------
 1977|      9|          growth_info_lower_bound.HasNoGrowthLeftAndNoDeleted())) {
 1978|       |    // Table without deleted slots (>95% cases) that needs to be resized.
 1979|      7|    return GrowToNextCapacityAndPrepareInsert(common, policy, hash);
 1980|      7|  }
 1981|      2|  if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 1982|      2|          growth_info_lower_bound.HasNoGrowthLeftAndHaveDeleted())) {
 1983|       |    // Table with deleted slots that needs to be rehashed or resized.
 1984|      0|    return RehashOrGrowToNextCapacityAndPrepareInsert(common, policy, hash);
 1985|      0|  }
 1986|       |  // Covers two cases:
 1987|       |  // 1. Table with deleted slots that has space for the inserting element.
 1988|       |  // 2. Table without deleted slots that has space and GrowthInfoView was
 1989|       |  //    rebalanced.
 1990|      2|  FindInfo target = find_first_non_full(common, hash);
 1991|      2|  PrepareInsertCommon(common);
 1992|      2|  growth_info.OverwriteControlAsFull(common.control()[target.offset]);
 1993|      2|  SetCtrlInLargeTable(common, target.offset, H2(hash), policy.slot_size);
 1994|      2|  common.infoz().RecordInsertMiss(hash, target.probe_length);
 1995|      2|  return SlotAddress(common.slot_array(cap), target.offset, policy.slot_size);
 1996|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_134GrowToNextCapacityAndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1780|      7|    size_t new_hash) {
 1781|      7|  const size_t old_capacity = common.capacity();
 1782|      7|  ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |   66|      7|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1783|      7|      common.growth_info().GetGrowthLeftTotalSlow(old_capacity) == 0);
 1784|      7|  ABSL_SWISSTABLE_ASSERT(old_capacity > policy.soo_capacity());
  ------------------
  |  |   66|      7|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1785|      7|  ABSL_SWISSTABLE_ASSERT(!IsSmallCapacity(old_capacity));
  ------------------
  |  |   66|      7|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1786|      7|  ABSL_ASSUME(old_capacity > kMaxSmallCapacity);
  ------------------
  |  |  272|      7|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1787|       |
 1788|      7|  const size_t new_capacity = NextCapacity(old_capacity);
 1789|      7|  ctrl_t* old_ctrl = common.control();
 1790|      7|  void* old_slots = common.slot_array(old_capacity);
 1791|      7|  size_t old_blocked_element_count = common.blocked_element_count();
 1792|       |
 1793|      7|  HashtablezInfoHandle infoz = common.infoz();
 1794|      7|  const bool has_infoz = infoz.IsSampled();
 1795|      7|  common.set_capacity(new_capacity);
 1796|      7|  common.set_blocked_element_count_to_zero();
 1797|      7|  const size_t slot_size = policy.slot_size;
 1798|      7|  const size_t slot_align = policy.slot_align;
 1799|      7|  void* alloc = policy.get_char_alloc(common);
 1800|       |
 1801|      7|  const auto [new_ctrl, new_slots] =
 1802|      7|      AllocBackingArray(common, policy, new_capacity, has_infoz, alloc,
 1803|      7|                        /*blocked_element_count=*/0);
 1804|      7|  common.set_control(new_ctrl);
 1805|      7|  SanitizerPoisonMemoryRegion(new_slots, new_capacity * slot_size);
 1806|       |
 1807|      7|  h2_t new_h2 = H2(new_hash);
 1808|      7|  size_t total_probe_length = 0;
 1809|      7|  FindInfo find_info;
 1810|      7|  if (ABSL_PREDICT_TRUE(is_single_group(new_capacity))) {
  ------------------
  |  |  191|      7|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 2, False: 5]
  |  |  |  Branch (191:48): [Folded, False: 7]
  |  |  |  Branch (191:57): [True: 2, False: 5]
  |  |  ------------------
  ------------------
 1811|      2|    size_t offset;
 1812|      2|    const size_t old_size = common.size();
 1813|      2|    GrowIntoSingleGroupShuffleControlBytes(old_ctrl, old_capacity,
 1814|      2|                                           old_blocked_element_count, new_ctrl,
 1815|      2|                                           new_capacity);
 1816|       |    // We put the new element either at the beginning or at the end of the
 1817|       |    // table with approximately equal probability.
 1818|      2|    offset =
 1819|      2|        SingleGroupTableH1(new_hash, common.seed()) & 1 ? 0 : new_capacity - 1;
  ------------------
  |  Branch (1819:9): [True: 0, False: 2]
  ------------------
 1820|       |
 1821|      2|    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[offset]));
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1822|      2|    SetCtrlInSingleGroupTable(common, offset, new_h2, policy.slot_size);
 1823|      2|    find_info = FindInfo{offset, 0};
 1824|       |    // Single group tables have all slots full on resize. So we can transfer
 1825|       |    // all slots without checking the control bytes.
 1826|      2|    ABSL_SWISSTABLE_ASSERT(common.size() + old_blocked_element_count ==
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1827|      2|                           old_capacity);
 1828|      2|    void* target = NextSlot(new_slots, slot_size);
 1829|      2|    SanitizerUnpoisonMemoryRegion(target, old_size * slot_size);
 1830|      2|    policy.transfer_n(&common, target, old_slots, old_size);
 1831|      5|  } else {
 1832|      5|    total_probe_length =
 1833|      5|        GrowToNextCapacityDispatch(common, policy, old_ctrl, old_slots);
 1834|      5|    find_info = find_first_non_full(common, new_hash);
 1835|      5|    SetCtrlInLargeTable(common, find_info.offset, new_h2, policy.slot_size);
 1836|      5|  }
 1837|      7|  ABSL_SWISSTABLE_ASSERT(old_capacity > policy.soo_capacity());
  ------------------
  |  |   66|      7|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1838|      7|  (*policy.dealloc)(alloc, old_capacity, old_ctrl, slot_size, slot_align,
 1839|      7|                    has_infoz, old_blocked_element_count);
 1840|      7|  PrepareInsertCommon(common);
 1841|      7|  ResetGrowthLeft(GetGrowthInfoFromControl(new_ctrl), new_capacity,
 1842|      7|                  common.size());
 1843|       |
 1844|      7|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|      7|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 7]
  |  |  |  Branch (190:49): [Folded, False: 7]
  |  |  |  Branch (190:58): [True: 0, False: 7]
  |  |  ------------------
  ------------------
 1845|      0|    ReportGrowthToInfoz(common, infoz, new_hash, total_probe_length,
 1846|      0|                        find_info.probe_length);
 1847|      0|  }
 1848|      7|  return SlotAddress(new_slots, find_info.offset, policy.slot_size);
 1849|      7|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_138GrowIntoSingleGroupShuffleControlBytesEPNS1_6ctrl_tEmmS4_m:
 1233|      2|                                            size_t new_capacity) {
 1234|      2|  ABSL_SWISSTABLE_ASSERT(is_single_group(new_capacity));
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1235|      2|  constexpr size_t kHalfWidth = Group::kWidth / 2;
 1236|      2|  ABSL_ASSUME(old_capacity < kHalfWidth);
  ------------------
  |  |  272|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1237|      2|  ABSL_ASSUME(old_capacity > 0);
  ------------------
  |  |  272|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1238|      2|  static_assert(Group::kWidth == 8 || Group::kWidth == 16,
 1239|      2|                "Group size is not supported.");
 1240|       |
 1241|       |  // NOTE: operations are done with compile time known size = 8.
 1242|       |  // Compiler optimizes that into single ASM operation.
 1243|       |
 1244|       |  // Load the bytes from old_capacity. This contains
 1245|       |  // - the sentinel byte
 1246|       |  // - all the old control bytes
 1247|       |  // - the rest is filled with kEmpty bytes
 1248|       |  // Example:
 1249|       |  // old_ctrl =     012S012EEEEEEEEE...
 1250|       |  // copied_bytes = S012EEEE
 1251|       |  // Example with blocked elements:
 1252|       |  // old_ctrl =     01SS01SEEEEEEEEE...
 1253|       |  // copied_bytes = S01SEEEE
 1254|      2|  uint64_t copied_bytes = absl::little_endian::Load64(old_ctrl + old_capacity);
 1255|       |
 1256|       |  // We change the sentinel byte to kEmpty before storing to both the start of
 1257|       |  // the new_ctrl, and past the end of the new_ctrl later for the new cloned
 1258|       |  // bytes. Note that this is faster than setting the sentinel byte to kEmpty
 1259|       |  // after the copy directly in new_ctrl because we are limited on store
 1260|       |  // bandwidth.
 1261|      2|  static constexpr uint64_t kEmptyXorSentinel =
 1262|      2|      static_cast<uint8_t>(ctrl_t::kEmpty) ^
 1263|      2|      static_cast<uint8_t>(ctrl_t::kSentinel);
 1264|       |
 1265|       |  // Replace the first byte kSentinel with kEmpty.
 1266|       |  // Resulting bytes will be shifted by one byte old control blocks.
 1267|       |  // Example:
 1268|       |  // old_ctrl = 012S012EEEEEEEEE...
 1269|       |  // before =   S012EEEE
 1270|       |  // after  =   E012EEEE
 1271|      2|  copied_bytes ^= kEmptyXorSentinel;
 1272|       |
 1273|      2|  if (ABSL_PREDICT_FALSE(old_blocked_element_count > 0)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 1274|       |    // Replacing blocked sentinel elements with kEmpty.
 1275|      0|    static constexpr uint64_t kAllBytesEmptyXorSentinel =
 1276|      0|        kEmptyXorSentinel * uint64_t{0x0101010101010101};
 1277|      0|    uint64_t blocked_mask = kAllBytesEmptyXorSentinel;
 1278|       |    // Keep old_blocked_element_count bytes in the mask.
 1279|      0|    blocked_mask >>= 64 - old_blocked_element_count * 8;
 1280|       |    // Shift the mask to the start of the blocked elements bytes.
 1281|      0|    blocked_mask <<= (old_capacity - old_blocked_element_count + 1) * 8;
 1282|       |    // Example with blocked elements:
 1283|       |    // old_ctrl = 0SSS0SSEEEEEEEEE...
 1284|       |    // before =   E0SSEEEE
 1285|       |    // after  =   E0EEEEEE
 1286|      0|    copied_bytes ^= blocked_mask;
 1287|      0|  }
 1288|       |
 1289|      2|  if (Group::kWidth == 8) {
  ------------------
  |  Branch (1289:7): [Folded, False: 2]
  ------------------
 1290|       |    // With group size 8, we can grow with two write operations.
 1291|      0|    ABSL_SWISSTABLE_ASSERT(old_capacity < 8 &&
  ------------------
  |  |   66|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1292|      0|                           "old_capacity is too large for group size 8");
 1293|      0|    absl::little_endian::Store64(new_ctrl, copied_bytes);
 1294|       |
 1295|      0|    static constexpr uint64_t kSentinal64 =
 1296|      0|        static_cast<uint8_t>(ctrl_t::kSentinel);
 1297|       |
 1298|       |    // Prepend kSentinel byte to the beginning of copied_bytes.
 1299|       |    // We have maximum 3 non-empty bytes at the beginning of copied_bytes for
 1300|       |    // group size 8.
 1301|       |    // Example:
 1302|       |    // old_ctrl = 012S012EEEE
 1303|       |    // before =   E012EEEE
 1304|       |    // after  =   SE012EEE
 1305|      0|    copied_bytes = (copied_bytes << 8) ^ kSentinal64;
 1306|      0|    absl::little_endian::Store64(new_ctrl + new_capacity, copied_bytes);
 1307|       |    // Example for capacity 3:
 1308|       |    // old_ctrl = 012S012EEEE
 1309|       |    // After the first store:
 1310|       |    //           >!
 1311|       |    // new_ctrl = E012EEEE???????
 1312|       |    // After the second store:
 1313|       |    //                  >!
 1314|       |    // new_ctrl = E012EEESE012EEE
 1315|      0|    return;
 1316|      0|  }
 1317|       |
 1318|      2|  ABSL_SWISSTABLE_ASSERT(Group::kWidth == 16);  // NOLINT(misc-static-assert)
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1319|       |
 1320|       |  // Fill the second half of the main control bytes with kEmpty.
 1321|       |  // For small capacity that may write into mirrored control bytes.
 1322|       |  // It is fine as we will overwrite all the bytes later.
 1323|      2|  std::memset(new_ctrl + kHalfWidth, static_cast<int8_t>(ctrl_t::kEmpty),
 1324|      2|              kHalfWidth);
 1325|       |  // Fill the second half of the mirrored control bytes with kEmpty.
 1326|      2|  std::memset(new_ctrl + new_capacity + kHalfWidth,
 1327|      2|              static_cast<int8_t>(ctrl_t::kEmpty), kHalfWidth);
 1328|       |  // Copy the first half of the non-mirrored control bytes.
 1329|      2|  absl::little_endian::Store64(new_ctrl, copied_bytes);
 1330|      2|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
 1331|       |  // Copy the first half of the mirrored control bytes.
 1332|      2|  absl::little_endian::Store64(new_ctrl + new_capacity + 1, copied_bytes);
 1333|       |
 1334|       |  // Example for growth capacity 1->3:
 1335|       |  // old_ctrl =                  0S0EEEEEEEEEEEEEE
 1336|       |  // new_ctrl at the end =       E0ESE0EEEEEEEEEEEEE
 1337|       |  //                                    >!
 1338|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???
 1339|       |  //                                       >!
 1340|       |  // new_ctrl after 2nd memset = ????????EEEEEEEEEEE
 1341|       |  //                            >!
 1342|       |  // new_ctrl after 1st store =  E0EEEEEEEEEEEEEEEEE
 1343|       |  // new_ctrl after kSentinel =  E0ESEEEEEEEEEEEEEEE
 1344|       |  //                                >!
 1345|       |  // new_ctrl after 2nd store =  E0ESE0EEEEEEEEEEEEE
 1346|       |
 1347|       |  // Example for growth capacity 3->7:
 1348|       |  // old_ctrl =                  012S012EEEEEEEEEEEE
 1349|       |  // new_ctrl at the end =       E012EEESE012EEEEEEEEEEE
 1350|       |  //                                    >!
 1351|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???????
 1352|       |  //                                           >!
 1353|       |  // new_ctrl after 2nd memset = ????????EEEEEEEEEEEEEEE
 1354|       |  //                            >!
 1355|       |  // new_ctrl after 1st store =  E012EEEEEEEEEEEEEEEEEEE
 1356|       |  // new_ctrl after kSentinel =  E012EEESEEEEEEEEEEEEEEE
 1357|       |  //                                >!
 1358|       |  // new_ctrl after 2nd store =  E012EEESE012EEEEEEEEEEE
 1359|       |
 1360|       |  // Example for growth capacity 7->15:
 1361|       |  // old_ctrl =                  0123456S0123456EEEEEEEE
 1362|       |  // new_ctrl at the end =       E0123456EEEEEEESE0123456EEEEEEE
 1363|       |  //                                    >!
 1364|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???????????????
 1365|       |  //                                                   >!
 1366|       |  // new_ctrl after 2nd memset = ????????EEEEEEEE???????EEEEEEEE
 1367|       |  //                            >!
 1368|       |  // new_ctrl after 1st store =  E0123456EEEEEEEE???????EEEEEEEE
 1369|       |  // new_ctrl after kSentinel =  E0123456EEEEEEES???????EEEEEEEE
 1370|       |  //                                            >!
 1371|       |  // new_ctrl after 2nd store =  E0123456EEEEEEESE0123456EEEEEEE
 1372|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_126GrowToNextCapacityDispatchERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1686|      5|                                  ctrl_t* old_ctrl, void* old_slots) {
 1687|      5|  const size_t new_capacity = common.capacity();
 1688|      5|  if (ABSL_PREDICT_TRUE(new_capacity <= kMaxLocalBufferNewCapacity)) {
  ------------------
  |  |  191|      5|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 4, False: 1]
  |  |  |  Branch (191:48): [Folded, False: 5]
  |  |  |  Branch (191:57): [True: 4, False: 1]
  |  |  ------------------
  ------------------
 1689|      4|    return GrowToNextCapacityThatFitsInLocalBuffer(common, policy, old_ctrl,
 1690|      4|                                                   old_slots);
 1691|      4|  } else {
 1692|      1|    return GrowToNextCapacityOverflowLocalBuffer(common, policy, old_ctrl,
 1693|      1|                                                 old_slots);
 1694|      1|  }
 1695|      5|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_139GrowToNextCapacityThatFitsInLocalBufferERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1636|      4|    ctrl_t* old_ctrl, void* old_slots) {
 1637|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= kMaxLocalBufferNewCapacity);
  ------------------
  |  |   66|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1638|      4|  return GrowToNextCapacity<
 1639|      4|      ProbedItemEncoder<ProbedItem4Bytes, /*kGuaranteedFitToBuffer=*/true>>(
 1640|      4|      common, policy, old_ctrl, old_slots);
 1641|      4|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1617|      4|                          ctrl_t* old_ctrl, void* old_slots) {
 1618|      4|  using ProbedItem = typename Encoder::ProbedItem;
 1619|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   66|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1620|      4|  Encoder encoder(old_ctrl);
 1621|      4|  policy.transfer_unprobed_elements_to_next_capacity(
 1622|      4|      common, old_ctrl, old_slots, &encoder,
 1623|      4|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1624|      4|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1625|      4|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1626|      4|      });
 1627|      4|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1628|      4|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1629|      4|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEC2EPNS1_6ctrl_tE:
 1485|      4|  explicit ProbedItemEncoder(ctrl_t* control) : control_(control) {}
raw_hash_set.cc:_ZZN4absl12lts_2026081718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPvENKUlSF_hmmE_clESF_hmm:
 1623|      2|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1624|      2|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1625|      2|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1626|      2|      });
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EE10EncodeItemES5_:
 1488|      2|  void EncodeItem(ProbedItem item) {
 1489|      2|    if (ABSL_PREDICT_FALSE(!kGuaranteedFitToBuffer && pos_ >= end_)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [Folded, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:59): [Folded, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1490|      0|      return ProcessEncodeWithOverflow(item);
 1491|      0|    }
 1492|      2|    ABSL_SWISSTABLE_ASSERT(pos_ < end_);
  ------------------
  |  |   66|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1493|      2|    *pos_ = item;
 1494|      2|    ++pos_;
 1495|      2|  }
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_130InitializeMirroredControlBytesEPNS1_6ctrl_tEm:
 1461|      5|void InitializeMirroredControlBytes(ctrl_t* new_ctrl, size_t new_capacity) {
 1462|      5|  std::memcpy(new_ctrl + new_capacity,
 1463|       |              // We own GrowthInfo just before control bytes. So it is ok
 1464|       |              // to read one byte from it.
 1465|      5|              new_ctrl - 1, Group::kWidth);
 1466|      5|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
 1467|      5|}
raw_hash_set.cc:_ZNK4absl12lts_2026081718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1502|      4|                                void* old_slots) const {
 1503|      4|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1503:9): [True: 3, False: 1]
  ------------------
 1504|      3|      return 0;
 1505|      3|    }
 1506|      1|    if constexpr (kGuaranteedFitToBuffer) {
 1507|      1|      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1508|      1|    }
 1509|      0|    size_t total_probe_length = DecodeAndInsertImpl(
 1510|      1|        common, policy, buffer_,
 1511|      1|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1511:9): [True: 0, False: 1]
  ------------------
 1512|      1|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1512:9): [True: 0, False: 1]
  ------------------
 1513|      0|      return total_probe_length;
 1514|      0|    }
 1515|      1|    total_probe_length +=
 1516|      1|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1517|      1|    return total_probe_length;
 1518|      1|  }
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_119DecodeAndInsertImplINS1_14ProbedItemImplIjLm32EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPKT_SD_Pv:
 1384|      2|    const ProbedItem* start, const ProbedItem* end, void* old_slots) {
 1385|      2|  const HashtableCapacity new_capacity = c.capacity_impl();
 1386|       |
 1387|      2|  void* new_slots = c.slot_array(new_capacity.capacity());
 1388|      2|  ctrl_t* new_ctrl = c.control();
 1389|      2|  size_t total_probe_length = 0;
 1390|       |
 1391|      2|  const size_t slot_size = policy.slot_size;
 1392|      2|  auto transfer_n = policy.transfer_n;
 1393|       |
 1394|      5|  for (; start < end; ++start) {
  ------------------
  |  Branch (1394:10): [True: 3, False: 2]
  ------------------
 1395|      3|    const FindInfo target = find_first_non_full_from_h1(
 1396|      3|        new_ctrl, static_cast<size_t>(start->h1), new_capacity);
 1397|      3|    total_probe_length += target.probe_length;
 1398|      3|    const size_t old_index = static_cast<size_t>(start->source_offset);
 1399|      3|    const size_t new_i = target.offset;
 1400|      3|    ABSL_SWISSTABLE_ASSERT(old_index < new_capacity.capacity() / 2);
  ------------------
  |  |   66|      3|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1401|      3|    ABSL_SWISSTABLE_ASSERT(new_i < new_capacity.capacity());
  ------------------
  |  |   66|      3|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1402|       |    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_i]));
  ------------------
  |  |   66|      3|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1403|      3|    void* src_slot = SlotAddress(old_slots, old_index, slot_size);
 1404|      3|    void* dst_slot = SlotAddress(new_slots, new_i, slot_size);
 1405|      3|    SanitizerUnpoisonMemoryRegion(dst_slot, slot_size);
 1406|      3|    transfer_n(&c, dst_slot, src_slot, 1);
 1407|      3|    SetCtrlInLargeTable(c, new_i, static_cast<h2_t>(start->h2), slot_size);
 1408|      3|  }
 1409|      2|  return total_probe_length;
 1410|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_137GrowToNextCapacityOverflowLocalBufferERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1669|      1|    ctrl_t* old_ctrl, void* old_slots) {
 1670|      1|  const size_t new_capacity = common.capacity();
 1671|      1|  if (ABSL_PREDICT_TRUE(new_capacity <= ProbedItem4Bytes::kMaxNewCapacity)) {
  ------------------
  |  |  191|      1|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 1]
  |  |  |  Branch (191:57): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 1672|      1|    return GrowToNextCapacity4BytesEncoder(common, policy, old_ctrl, old_slots);
 1673|      1|  }
 1674|      0|  if (ABSL_PREDICT_TRUE(new_capacity <= ProbedItem8Bytes::kMaxNewCapacity)) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1675|      0|    return GrowToNextCapacity8BytesEncoder(common, policy, old_ctrl, old_slots);
 1676|      0|  }
 1677|       |  // 16 bytes encoding supports the maximum swisstable capacity.
 1678|      0|  return GrowToNextCapacity16BytesEncoder(common, policy, old_ctrl, old_slots);
 1679|      0|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_131GrowToNextCapacity4BytesEncoderERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1647|      1|                                       ctrl_t* old_ctrl, void* old_slots) {
 1648|      1|  return GrowToNextCapacity<ProbedItemEncoder<ProbedItem4Bytes>>(
 1649|      1|      common, policy, old_ctrl, old_slots);
 1650|      1|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1617|      1|                          ctrl_t* old_ctrl, void* old_slots) {
 1618|      1|  using ProbedItem = typename Encoder::ProbedItem;
 1619|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1620|      1|  Encoder encoder(old_ctrl);
 1621|      1|  policy.transfer_unprobed_elements_to_next_capacity(
 1622|      1|      common, old_ctrl, old_slots, &encoder,
 1623|      1|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1624|      1|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1625|      1|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1626|      1|      });
 1627|      1|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1628|      1|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1629|      1|}
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EEC2EPNS1_6ctrl_tE:
 1485|      1|  explicit ProbedItemEncoder(ctrl_t* control) : control_(control) {}
raw_hash_set.cc:_ZZN4absl12lts_2026081718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPvENKUlSF_hmmE_clESF_hmm:
 1623|      1|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1624|      1|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1625|      1|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1626|      1|      });
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EE10EncodeItemES5_:
 1488|      1|  void EncodeItem(ProbedItem item) {
 1489|      1|    if (ABSL_PREDICT_FALSE(!kGuaranteedFitToBuffer && pos_ >= end_)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:59): [True: 1, Folded]
  |  |  |  Branch (190:59): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1490|      0|      return ProcessEncodeWithOverflow(item);
 1491|      0|    }
 1492|      1|    ABSL_SWISSTABLE_ASSERT(pos_ < end_);
  ------------------
  |  |   66|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1493|      1|    *pos_ = item;
 1494|      1|    ++pos_;
 1495|      1|  }
raw_hash_set.cc:_ZNK4absl12lts_2026081718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1502|      1|                                void* old_slots) const {
 1503|      1|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1503:9): [True: 0, False: 1]
  ------------------
 1504|      0|      return 0;
 1505|      0|    }
 1506|       |    if constexpr (kGuaranteedFitToBuffer) {
 1507|       |      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1508|       |    }
 1509|      1|    size_t total_probe_length = DecodeAndInsertImpl(
 1510|      1|        common, policy, buffer_,
 1511|      1|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1511:9): [True: 0, False: 1]
  ------------------
 1512|      1|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1512:9): [True: 1, False: 0]
  ------------------
 1513|      1|      return total_probe_length;
 1514|      1|    }
 1515|      0|    total_probe_length +=
 1516|      0|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1517|      0|    return total_probe_length;
 1518|      1|  }
raw_hash_set.cc:_ZN4absl12lts_2026081718container_internal12_GLOBAL__N_119SetCtrlInLargeTableERKNS1_12CommonFieldsEmhm:
  581|     10|                                size_t slot_size) {
  582|     10|  SetCtrlInLargeTable(c, i, static_cast<ctrl_t>(h), slot_size);
  583|     10|}

_ZN4absl12lts_2026081718container_internal34CommonFieldsGenerationInfoDisabled36maybe_increment_generation_on_insertEv:
  930|    554|  void maybe_increment_generation_on_insert() {}
_ZN4absl12lts_2026081718container_internal34CommonFieldsGenerationInfoDisabled21reset_reserved_growthEmm:
  932|      2|  void reset_reserved_growth(size_t, size_t) {}
_ZN4absl12lts_2026081718container_internal34CommonFieldsGenerationInfoDisabled19set_reserved_growthEm:
  934|      3|  void set_reserved_growth(size_t) {}
_ZN4absl12lts_2026081718container_internal34CommonFieldsGenerationInfoDisabled20set_reservation_sizeEm:
  936|      5|  void set_reservation_size(size_t) {}
_ZNK4absl12lts_2026081718container_internal34CommonFieldsGenerationInfoDisabled10generationEv:
  937|     11|  GenerationType generation() const { return 0; }
_ZN4absl12lts_2026081718container_internal34CommonFieldsGenerationInfoDisabled14set_generationEh:
  938|     11|  void set_generation(GenerationType) {}
_ZN4absl12lts_2026081718container_internal34CommonFieldsGenerationInfoDisabled18set_generation_ptrEPh:
  940|     11|  void set_generation_ptr(GenerationType*) {}
_ZN4absl12lts_2026081718container_internal20GrowthInfoLowerBoundC2Eh:
 1023|    567|      : growth_left_(growth_left) {}
_ZNK4absl12lts_2026081718container_internal20GrowthInfoLowerBound25HasNoDeletedAndGrowthLeftEv:
 1028|    552|  constexpr bool HasNoDeletedAndGrowthLeft() const {
 1029|    552|    return static_cast<int8_t>(growth_left_) > 0;
 1030|    552|  }
_ZNK4absl12lts_2026081718container_internal20GrowthInfoLowerBound23HasDeletedAndGrowthLeftEv:
 1035|      3|  constexpr bool HasDeletedAndGrowthLeft() const {
 1036|      3|    return growth_left_ > kDeletedBit;
 1037|      3|  }
_ZNK4absl12lts_2026081718container_internal20GrowthInfoLowerBound27HasNoGrowthLeftAndNoDeletedEv:
 1042|      9|  constexpr bool HasNoGrowthLeftAndNoDeleted() const {
 1043|      9|    return growth_left_ == 0;
 1044|      9|  }
_ZNK4absl12lts_2026081718container_internal20GrowthInfoLowerBound29HasNoGrowthLeftAndHaveDeletedEv:
 1048|      2|  constexpr bool HasNoGrowthLeftAndHaveDeleted() const {
 1049|      2|    return growth_left_ == kDeletedBit;
 1050|      2|  }
_ZNK4absl12lts_2026081718container_internal20GrowthInfoLowerBound13GetGrowthLeftEv:
 1061|      3|  constexpr uint8_t GetGrowthLeft() const {
 1062|      3|    return growth_left_ & kGrowthLeftMask;
 1063|      3|  }
_ZN4absl12lts_2026081718container_internal18GrowthInfoAccessorC2EPv:
 1078|    572|      : growth_info_lower_bound_(reinterpret_cast<uint8_t*>(control) - 1 -
 1079|    572|                                 NumGenerationBytes()) {}
_ZN4absl12lts_2026081718container_internal18GrowthInfoAccessor20OverwriteEmptyAsFullEv:
 1096|    543|  void OverwriteEmptyAsFull() {
 1097|       |    ABSL_SWISSTABLE_ASSERT(GetGrowthLeftLowerBound() > 0);
  ------------------
  |  |  257|    543|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1098|    543|    --(*growth_info_lower_bound_);
 1099|    543|  }
_ZN4absl12lts_2026081718container_internal18GrowthInfoAccessor22OverwriteControlAsFullENS1_6ctrl_tE:
 1103|      2|  void OverwriteControlAsFull(ctrl_t ctrl) {
 1104|       |    ABSL_SWISSTABLE_ASSERT(GetGrowthLeftLowerBound() >=
  ------------------
  |  |  257|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1105|      2|                           static_cast<size_t>(IsEmpty(ctrl)));
 1106|      2|    *growth_info_lower_bound_ -= static_cast<size_t>(IsEmpty(ctrl));
 1107|      2|  }
_ZNK4absl12lts_2026081718container_internal18GrowthInfoAccessor23GetGrowthInfoLowerBoundEv:
 1116|    561|  GrowthInfoLowerBound GetGrowthInfoLowerBound() const {
 1117|    561|    return GrowthInfoLowerBound(*growth_info_lower_bound_);
 1118|    561|  }
_ZNK4absl12lts_2026081718container_internal18GrowthInfoAccessor20full_growth_info_ptrEv:
 1131|      6|  void* full_growth_info_ptr() const { return growth_info_lower_bound_ - 7; }
_ZN4absl12lts_2026081718container_internal16RawHashSetLayoutC2Emmmbm:
 1191|     19|      : control_offset_(MetadataBeforeControlSize(has_infoz, capacity)),
 1192|     19|        generation_offset_(control_offset_ - NumGenerationBytes()),
 1193|     19|        slot_offset_(control_offset_ + NumControlBytes(capacity)) {
 1194|     19|    ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |  257|     19|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1195|     19|    size_t aligned_slot_offset = AlignUpTo(slot_offset_, slot_align);
 1196|     19|    size_t slot_array_padding = aligned_slot_offset - slot_offset_;
 1197|     19|    slot_offset_ = aligned_slot_offset;
 1198|     19|    ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |  257|     19|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1199|     19|        slot_size <=
 1200|     19|        ((std::numeric_limits<size_t>::max)() - slot_offset_) / capacity);
 1201|     19|    control_offset_ += slot_array_padding;
 1202|     19|    generation_offset_ += slot_array_padding;
 1203|       |    ABSL_SWISSTABLE_ASSERT(!IsSmallCapacity(capacity) ||
  ------------------
  |  |  257|     19|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1204|     19|                           control_offset_ == slot_offset_);
 1205|     19|    alloc_size_ = slot_offset_ + (capacity - blocked_element_count) * slot_size;
 1206|     19|  }
_ZNK4absl12lts_2026081718container_internal16RawHashSetLayout14control_offsetEv:
 1210|     19|  size_t control_offset() const { return control_offset_; }
_ZNK4absl12lts_2026081718container_internal16RawHashSetLayout17generation_offsetEv:
 1214|     11|  size_t generation_offset() const { return generation_offset_; }
_ZNK4absl12lts_2026081718container_internal16RawHashSetLayout11slot_offsetEv:
 1218|     11|  size_t slot_offset() const { return slot_offset_; }
_ZNK4absl12lts_2026081718container_internal16RawHashSetLayout10alloc_sizeEv:
 1222|     27|  size_t alloc_size() const { return alloc_size_; }
_ZN4absl12lts_2026081718container_internal9HeapOrSoo7controlEv:
 1260|     11|  MaybeInitializedPtr<ctrl_t>& control() {
 1261|     11|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.control);
  ------------------
  |  |  484|     11|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1262|     11|  }
_ZN4absl12lts_2026081718container_internal12CommonFields11set_controlEPNS1_6ctrl_tE:
 1333|     11|  void set_control(ctrl_t* c) { heap_or_soo_.control().set(c); }
_ZN4absl12lts_2026081718container_internal12CommonFields16set_size_to_zeroEv:
 1350|      1|  void set_size_to_zero() { inline_data_.set_size(0); }
_ZN4absl12lts_2026081718container_internal12CommonFields14increment_sizeEv:
 1359|    554|  void increment_size() {
 1360|       |    ABSL_SWISSTABLE_ASSERT(size() < capacity());
  ------------------
  |  |  257|    554|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1361|    554|    inline_data_.increment_size();
 1362|    554|  }
_ZNK4absl12lts_2026081718container_internal12CommonFields5emptyEv:
 1371|      5|  bool empty() const { return inline_data_.empty(); }
_ZN4absl12lts_2026081718container_internal12CommonFields17generate_new_seedEb:
 1384|      3|  void generate_new_seed(bool has_infoz) {
 1385|       |    // Note: we can't use has_infoz() here because we set has_infoz later than
 1386|       |    // we generate the seed.
 1387|      3|    if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|      3|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 3]
  |  |  |  Branch (190:49): [Folded, False: 3]
  |  |  |  Branch (190:58): [True: 0, False: 3]
  |  |  ------------------
  ------------------
 1388|      0|      inline_data_.set_sampled_seed();
 1389|      0|      return;
 1390|      0|    }
 1391|      3|    inline_data_.generate_new_seed();
 1392|      3|  }
_ZN4absl12lts_2026081718container_internal12CommonFields12set_capacityENS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEE:
 1406|     11|  void set_capacity(HashtableCapacity c) { inline_data_.set_capacity(c); }
_ZN4absl12lts_2026081718container_internal12CommonFields12set_capacityEm:
 1407|     11|  void set_capacity(size_t c) {
 1408|     11|    set_capacity(HashtableCapacity(c));
 1409|     11|  }
_ZNK4absl12lts_2026081718container_internal12CommonFields11growth_infoEv:
 1412|    562|  GrowthInfoAccessor growth_info() const {
 1413|       |    ABSL_SWISSTABLE_ASSERT(GrowthInfoSizeForCapacity(capacity()) > 0);
  ------------------
  |  |  257|    562|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1414|    562|    return GetGrowthInfoFromControl(control());
 1415|    562|  }
_ZNK4absl12lts_2026081718container_internal12CommonFields9has_infozEv:
 1417|    556|  bool has_infoz() const { return inline_data_.has_infoz(); }
_ZN4absl12lts_2026081718container_internal12CommonFields5infozEv:
 1425|    556|  HashtablezInfoHandle infoz() {
 1426|    556|    return has_infoz() ? infoz_ptr() : HashtablezInfoHandle();
  ------------------
  |  Branch (1426:12): [True: 0, False: 556]
  ------------------
 1427|    556|  }
_ZN4absl12lts_2026081718container_internal12CommonFields21reset_reserved_growthEm:
 1441|      2|  void reset_reserved_growth(size_t reservation) {
 1442|      2|    CommonFieldsGenerationInfo::reset_reserved_growth(reservation, size());
 1443|      2|  }
_ZNK4absl12lts_2026081718container_internal12CommonFields21blocked_element_countEv:
 1449|      8|  size_t blocked_element_count() const {
 1450|      8|    return inline_data_.blocked_element_count();
 1451|      8|  }
_ZN4absl12lts_2026081718container_internal12CommonFields26init_blocked_element_countEm:
 1456|      2|  void init_blocked_element_count(size_t count) {
 1457|      2|    inline_data_.init_blocked_element_count(count);
 1458|      2|  }
_ZN4absl12lts_2026081718container_internal12CommonFields33set_blocked_element_count_to_zeroEv:
 1459|      7|  void set_blocked_element_count_to_zero() {
 1460|      7|    inline_data_.set_blocked_element_count_to_zero();
 1461|      7|  }
_ZNK4absl12lts_2026081718container_internal15PolicyFunctions12soo_capacityEv:
 1967|      2|  uint8_t soo_capacity() const {
 1968|      2|    return static_cast<uint8_t>(soo_enabled ? SooCapacity() : 0);
  ------------------
  |  Branch (1968:33): [True: 0, False: 2]
  ------------------
 1969|      2|  }
_ZN4absl12lts_2026081718container_internal22MaxValidSizeForKeySizeILm8EEEmm:
 1998|      2|constexpr size_t MaxValidSizeForKeySize(size_t key_size) {
 1999|      2|  if (key_size < kSizeOfSizeT) return size_t{1} << 8 * key_size;
  ------------------
  |  Branch (1999:7): [True: 0, False: 2]
  ------------------
 2000|      2|  return (std::numeric_limits<size_t>::max)();
 2001|      2|}
_ZN4absl12lts_2026081718container_internal23MaxValidSizeForSlotSizeILm8EEEmm:
 2004|      2|constexpr size_t MaxValidSizeForSlotSize(size_t slot_size) {
 2005|      2|  if constexpr (kSizeOfSizeT == 8) {
 2006|       |    // For small slot sizes we are limited by HashtableStackData::kSizeBitCount.
 2007|      2|    if (slot_size < size_t{1} << (64 - HashtableInlineData::kSizeBitCount)) {
  ------------------
  |  Branch (2007:9): [True: 2, False: 0]
  ------------------
 2008|      2|      return MaxStorableSize();
 2009|      2|    }
 2010|      2|  }
 2011|      0|  return MaxSizeAtMaxValidCapacity<kSizeOfSizeT>(slot_size);
 2012|      2|}
_ZN4absl12lts_2026081718container_internal12MaxValidSizeILm8EEEmmm:
 2017|      2|constexpr size_t MaxValidSize(size_t key_size, size_t slot_size) {
 2018|      2|  return (std::min)(MaxValidSizeForKeySize<kSizeOfSizeT>(key_size),
 2019|      2|                    MaxValidSizeForSlotSize<kSizeOfSizeT>(slot_size));
 2020|      2|}
_ZN4absl12lts_2026081718container_internal23SentinelEmptyGenerationEv:
  265|     11|constexpr GenerationType SentinelEmptyGeneration() { return 0; }
_ZN4absl12lts_2026081718container_internal14NextGenerationEh:
  267|     11|constexpr GenerationType NextGeneration(GenerationType generation) {
  268|     11|  return ++generation == SentinelEmptyGeneration() ? ++generation : generation;
  ------------------
  |  Branch (268:10): [True: 0, False: 11]
  ------------------
  269|     11|}
_ZN4absl12lts_2026081718container_internal18NumGenerationBytesEv:
  276|    610|constexpr size_t NumGenerationBytes() { return 0; }
_ZN4absl12lts_2026081718container_internal15is_single_groupEm:
  404|      9|constexpr bool is_single_group(size_t capacity) {
  405|      9|  return capacity <= Group::kWidth;
  406|      9|}
_ZN4absl12lts_2026081718container_internal33IsCapacityValidForBlockedElementsEm:
  410|      2|constexpr bool IsCapacityValidForBlockedElements(size_t cap) {
  411|      2|  return !IsSmallCapacity(cap);
  412|      2|}
_ZN4absl12lts_2026081718container_internal12NextCapacityEm:
  420|      7|constexpr size_t NextCapacity(size_t n) {
  421|       |  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(n) || n == 0);
  ------------------
  |  |  257|      7|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  422|      7|  return n * 2 + 1;
  423|      7|}
_ZN4absl12lts_2026081718container_internal16CapacityToGrowthEm:
  444|     12|constexpr size_t CapacityToGrowth(size_t capacity) {
  445|     12|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |  257|     12|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  446|       |  // `capacity*7/8`
  447|     12|  if (capacity <= kMaxCapacityForLoadFactorOne) {
  ------------------
  |  Branch (447:7): [True: 7, False: 5]
  ------------------
  448|       |    // For small capacities we leave at most one empty slot.
  449|      7|    return capacity - (capacity >= Group::kWidth - 1);
  450|      7|  }
  451|      5|  return capacity - capacity / 8;
  452|     12|}
_ZN4absl12lts_2026081718container_internal14SizeToCapacityEm:
  459|      2|constexpr size_t SizeToCapacity(size_t size) {
  460|      2|  if (size == 0) {
  ------------------
  |  Branch (460:7): [True: 0, False: 2]
  ------------------
  461|      0|    return 0;
  462|      0|  }
  463|       |  // The minimum possible capacity is NormalizeCapacity(size).
  464|       |  // Shifting right `~size_t{}` by `leading_zeros` yields
  465|       |  // NormalizeCapacity(size).
  466|      2|  int leading_zeros = absl::countl_zero(
  467|      2|      size +
  468|       |      // Tables larger than half a group require at least one empty slot.
  469|      2|      (size >= Group::kWidth / 2));
  470|      2|  if (size < kMaxCapacityForLoadFactorOne) {
  ------------------
  |  Branch (470:7): [True: 1, False: 1]
  ------------------
  471|      1|    return (~size_t{}) >> leading_zeros;
  472|      1|  }
  473|      1|  constexpr size_t kLast3Bits = size_t{7} << (sizeof(size_t) * 8 - 3);
  474|       |  // max_size_for_next_capacity = max_load_factor * next_capacity
  475|       |  //                            = (7/8) * (~size_t{} >> leading_zeros)
  476|       |  //                            = (7/8*~size_t{}) >> leading_zeros
  477|       |  //                            = kLast3Bits >> leading_zeros
  478|      1|  size_t max_size_for_next_capacity = kLast3Bits >> leading_zeros;
  479|       |  // Decrease shift if size is too big for the minimum capacity.
  480|      1|  leading_zeros -= static_cast<int>(size > max_size_for_next_capacity);
  481|      1|  return (~size_t{}) >> leading_zeros;
  482|      2|}
_ZN4absl12lts_2026081718container_internal25GrowthInfoSizeForCapacityEm:
 1158|     21|constexpr size_t GrowthInfoSizeForCapacity(size_t capacity) {
 1159|     21|  if (IsSmallCapacity(capacity)) {
  ------------------
  |  Branch (1159:7): [True: 2, False: 19]
  ------------------
 1160|      2|    return 0;
 1161|      2|  }
 1162|     19|  return capacity <= GrowthInfoLowerBound::kMaxGrowthLeftLowerBound
  ------------------
  |  Branch (1162:10): [True: 14, False: 5]
  ------------------
 1163|     19|             ? sizeof(uint8_t)
 1164|     19|             : sizeof(uint64_t);
 1165|     21|}
_ZN4absl12lts_2026081718container_internal25MetadataBeforeControlSizeEbm:
 1169|     19|constexpr size_t MetadataBeforeControlSize(bool has_infoz, size_t capacity) {
 1170|     19|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|     19|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 19]
  |  |  |  Branch (190:49): [Folded, False: 19]
  |  |  |  Branch (190:58): [True: 0, False: 19]
  |  |  ------------------
  ------------------
 1171|       |    // We always allocate 8 bytes of growth info for sampled tables to allow
 1172|       |    // branchless access to infoz pointer.
 1173|      0|    return sizeof(HashtablezInfoHandle) + sizeof(uint64_t) +
 1174|      0|           NumGenerationBytes();
 1175|      0|  }
 1176|     19|  return GrowthInfoSizeForCapacity(capacity) + NumGenerationBytes();
 1177|     19|}
_ZN4absl12lts_2026081718container_internal9AlignUpToEmm:
 1181|     19|constexpr size_t AlignUpTo(size_t offset, size_t align) {
 1182|     19|  return (offset + align - 1) & (~align + 1);
 1183|     19|}
_ZN4absl12lts_2026081718container_internal24GetGrowthInfoFromControlEPNS1_6ctrl_tE:
 1279|    572|inline GrowthInfoAccessor GetGrowthInfoFromControl(ctrl_t* control) {
 1280|    572|  return GrowthInfoAccessor(control);
 1281|    572|}
_ZN4absl12lts_2026081718container_internal15MaxStorableSizeEv:
 1988|      2|constexpr size_t MaxStorableSize() {
 1989|      2|  return static_cast<size_t>(uint64_t{1}
 1990|      2|                             << HashtableInlineData::kSizeBitCount) -
 1991|      2|         1;
 1992|      2|}
_ZN4absl12lts_2026081718container_internal12SooSlotIndexEv:
 2027|      1|constexpr size_t SooSlotIndex() { return 1; }
_ZN4absl12lts_2026081718container_internal19MaybeInitializedPtrINS1_6ctrl_tEE3setEPS3_:
 1238|     11|  void set(T* ptr) { p = ptr; }
_ZN4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8set_sizeEm:
  719|      1|  void set_size(size_t size) {
  720|      1|    data_ =
  721|      1|        (data_ & kMetadataMask) | (static_cast<uint64_t>(size) << kSizeShift);
  722|      1|  }
_ZN4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE14increment_sizeEv:
  702|    554|  void increment_size() { data_ += kSizeOneNoMetadata; }
_ZNK4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE5emptyEv:
  708|      5|  bool empty() const { return data_ < kSizeOneNoMetadata; }
_ZN4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8set_seedEh:
  799|      3|  void set_seed(uint8_t seed) {
  800|      3|    data_ = (data_ & ~kSeedMask) | (seed & kSeedMask);
  801|      3|  }
_ZN4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE17generate_new_seedEv:
  728|      3|  void generate_new_seed() { set_seed(NextHashTableSeed()); }
_ZN4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE12set_capacityENS1_21HashtableCapacityImplILS3_1EEE:
  697|     11|  void set_capacity(HashtableCapacity c) { capacity_internal_ = c.ToRawData(); }
_ZNK4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE9has_infozEv:
  739|    556|  bool has_infoz() const {
  740|    556|    return ABSL_PREDICT_FALSE((data_ & kHasInfozMask) != 0);
  ------------------
  |  |  190|    556|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:49): [Folded, False: 556]
  |  |  |  Branch (190:58): [True: 0, False: 556]
  |  |  ------------------
  ------------------
  741|    556|  }
_ZNK4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE21blocked_element_countEv:
  747|      8|  size_t blocked_element_count() const {
  748|      8|    return (data_ & kBlockedElementMask) >> kBlockedElementsShift;
  749|      8|  }
_ZN4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE26init_blocked_element_countEm:
  754|      2|  void init_blocked_element_count(uint64_t count) {
  755|      2|    ABSL_SWISSTABLE_ASSERT(blocked_element_count() == 0);
  ------------------
  |  |  257|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  756|       |    ABSL_SWISSTABLE_ASSERT(count <= kMaxBlockedElementCount);
  ------------------
  |  |  257|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  757|      2|    data_ |= count << kBlockedElementsShift;
  758|      2|  }
_ZN4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE33set_blocked_element_count_to_zeroEv:
  759|      7|  void set_blocked_element_count_to_zero() { data_ &= ~kBlockedElementMask; }
_ZN4absl12lts_2026081718container_internal20AllocateBackingArrayILm8ENSt3__19allocatorIcEEEEPvS6_m:
 1900|     11|void* AllocateBackingArray(void* alloc, size_t n) {
 1901|     11|  return Allocate<AlignOfBackingArray>(static_cast<Alloc*>(alloc), n);
 1902|     11|}
_ZN4absl12lts_2026081718container_internal22DeallocateBackingArrayILm8ENSt3__19allocatorIcEEEEvPvmPNS1_6ctrl_tEmmbm:
 1907|      8|                            size_t blocked_element_count) {
 1908|      8|  RawHashSetLayout layout(capacity, slot_size, slot_align, had_infoz,
 1909|      8|                          blocked_element_count);
 1910|      8|  void* backing_array = ctrl - layout.control_offset();
 1911|       |  // Unpoison before returning the memory to the allocator.
 1912|      8|  SanitizerUnpoisonMemoryRegion(backing_array, layout.alloc_size());
 1913|      8|  Deallocate<AlignOfBackingArray>(static_cast<Alloc*>(alloc), backing_array,
 1914|      8|                                  layout.alloc_size());
 1915|      8|}

_ZN4absl12lts_2026081718container_internal14ProbedItemImplIjLm32EEC2Ehmm:
   59|      3|      : h2(h2_arg),
   60|      3|        source_offset(static_cast<IntType>(source_offset_arg)),
   61|      3|        h1(static_cast<IntType>(h1_arg)) {}

_ZN4absl12lts_2026081711FunctionRefIFvPN6google8protobuf5ArenaERPvEEC2IZNS3_8internal18GenericTypeHandlerINS3_11MessageLiteEE23GetNewFromPrototypeFuncEPKSD_EUlS5_S7_E_vEEOT_:
  112|    298|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026081711FunctionRefIFvPN6google8protobuf5ArenaERPvEEC2IZNS3_8internal18GenericTypeHandlerINS3_11MessageLiteEE23GetNewFromPrototypeFuncEPKSD_EUlS5_S7_E_EENSt3__110in_place_tEOT_:
  100|    298|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|    298|    absl::functional_internal::AssertNonNull(f);
  102|    298|    ptr_.obj = &f;
  103|    298|  }
_ZNK4absl12lts_2026081711FunctionRefIFmmEEclEm:
  164|      1|  R operator()(Args... args) const {
  165|      1|    return invoker_(ptr_, std::forward<Args>(args)...);
  166|      1|  }

_ZN4absl12lts_2026081719functional_internal12InvokeObjectIRZN6google8protobuf8internal18GenericTypeHandlerINS4_11MessageLiteEE23GetNewFromPrototypeFuncEPKS7_EUlPNS4_5ArenaERPvE_vJSC_SE_EEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   72|    298|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   73|    298|  using T = std::remove_reference_t<Obj>;
   74|    298|  return static_cast<R>(std::invoke(
   75|    298|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   76|    298|      std::forward<typename ForwardT<Args>::type>(args)...));
   77|    298|}
_ZN4absl12lts_2026081719functional_internal13AssertNonNullIZN6google8protobuf8internal18GenericTypeHandlerINS4_11MessageLiteEE23GetNewFromPrototypeFuncEPKS7_EUlPNS4_5ArenaERPvE_EEvRKT_:
  134|    298|void AssertNonNull(const F&) {}

_ZN4absl12lts_2026081716strings_internal28STLStringResizeUninitializedINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEEvPT_m:
   68|    298|inline void STLStringResizeUninitialized(string_type* s, size_t new_size) {
   69|    298|  ResizeUninitializedTraits<string_type>::Resize(s, new_size);
   70|    298|}
_ZN4absl12lts_2026081716strings_internal25ResizeUninitializedTraitsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE6ResizeEPS9_m:
   48|    298|  static void Resize(string_type* s, size_t new_size) {
   49|    298|    s->__resize_default_init(new_size);
   50|    298|  }

_ZN4absl12lts_2026081719str_format_internal13ConvertIntArgIiEEbT_NS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  369|    256|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  370|    256|  using U = typename MakeUnsigned<T>::type;
  371|    256|  IntDigits as_digits;
  372|       |
  373|       |  // This odd casting is due to a bug in -Wswitch behavior in gcc49 which causes
  374|       |  // it to complain about a switch/case type mismatch, even though both are
  375|       |  // FormatConversionChar.  Likely this is because at this point
  376|       |  // FormatConversionChar is declared, but not defined.
  377|    256|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  378|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (378:5): [True: 0, False: 256]
  ------------------
  379|      0|      return (std::is_same_v<T, wchar_t> || (conv.length_mod() == LengthMod::l))
  ------------------
  |  Branch (379:15): [Folded, False: 0]
  |  Branch (379:45): [True: 0, False: 0]
  ------------------
  380|      0|                 ? ConvertWCharTImpl(static_cast<wchar_t>(v), conv, sink)
  381|      0|                 : ConvertCharImpl(static_cast<char>(v), conv, sink);
  382|       |
  383|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::o):
  ------------------
  |  Branch (383:5): [True: 0, False: 256]
  ------------------
  384|      0|      as_digits.PrintAsOct(static_cast<U>(v));
  385|      0|      break;
  386|       |
  387|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::x):
  ------------------
  |  Branch (387:5): [True: 0, False: 256]
  ------------------
  388|      0|      as_digits.PrintAsHexLower(static_cast<U>(v));
  389|      0|      break;
  390|    256|    case static_cast<uint8_t>(FormatConversionCharInternal::X):
  ------------------
  |  Branch (390:5): [True: 256, False: 0]
  ------------------
  391|    256|      as_digits.PrintAsHexUpper(static_cast<U>(v));
  392|    256|      break;
  393|       |
  394|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::u):
  ------------------
  |  Branch (394:5): [True: 0, False: 256]
  ------------------
  395|      0|      as_digits.PrintAsDec(static_cast<U>(v));
  396|      0|      break;
  397|       |
  398|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::d):
  ------------------
  |  Branch (398:5): [True: 0, False: 256]
  ------------------
  399|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (399:5): [True: 0, False: 256]
  ------------------
  400|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (400:5): [True: 0, False: 256]
  ------------------
  401|      0|      as_digits.PrintAsDec(v);
  402|      0|      break;
  403|       |
  404|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::a):
  ------------------
  |  Branch (404:5): [True: 0, False: 256]
  ------------------
  405|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (405:5): [True: 0, False: 256]
  ------------------
  406|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (406:5): [True: 0, False: 256]
  ------------------
  407|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (407:5): [True: 0, False: 256]
  ------------------
  408|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (408:5): [True: 0, False: 256]
  ------------------
  409|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (409:5): [True: 0, False: 256]
  ------------------
  410|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (410:5): [True: 0, False: 256]
  ------------------
  411|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (411:5): [True: 0, False: 256]
  ------------------
  412|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  413|       |
  414|      0|    default:
  ------------------
  |  Branch (414:5): [True: 0, False: 256]
  ------------------
  415|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  272|      0|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  416|    256|  }
  417|       |
  418|    256|  if (conv.is_basic()) {
  ------------------
  |  Branch (418:7): [True: 0, False: 256]
  ------------------
  419|      0|    sink->Append(as_digits.with_neg_and_zero());
  420|      0|    return true;
  421|      0|  }
  422|    256|  return ConvertIntImplInnerSlow(as_digits, conv, sink);
  423|    256|}
_ZN4absl12lts_2026081719str_format_internal17FormatConvertImplEiNS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  588|    256|                                        FormatSinkImpl *sink) {
  589|    256|  return {ConvertIntArg(v, conv, sink)};
  590|    256|}
arg.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_113ReducePaddingEmPm:
   54|    256|void ReducePadding(size_t n, size_t *capacity) {
   55|    256|  *capacity = Excess(n, *capacity);
   56|    256|}
arg.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_123ConvertIntImplInnerSlowERKNS2_9IntDigitsENS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  239|    256|                             FormatSinkImpl *sink) {
  240|       |  // Print as a sequence of Substrings:
  241|       |  //   [left_spaces][sign][base_indicator][zeroes][formatted][right_spaces]
  242|    256|  size_t fill = 0;
  243|    256|  if (conv.width() >= 0)
  ------------------
  |  Branch (243:7): [True: 256, False: 0]
  ------------------
  244|    256|    fill = static_cast<size_t>(conv.width());
  245|       |
  246|    256|  string_view formatted = as_digits.without_neg_or_zero();
  247|    256|  ReducePadding(formatted, &fill);
  248|       |
  249|    256|  string_view sign = SignColumn(as_digits.is_negative(), conv);
  250|    256|  ReducePadding(sign, &fill);
  251|       |
  252|    256|  string_view base_indicator = BaseIndicator(as_digits, conv);
  253|    256|  ReducePadding(base_indicator, &fill);
  254|       |
  255|    256|  bool precision_specified = conv.precision() >= 0;
  256|    256|  size_t precision =
  257|    256|      precision_specified ? static_cast<size_t>(conv.precision()) : size_t{1};
  ------------------
  |  Branch (257:7): [True: 0, False: 256]
  ------------------
  258|       |
  259|    256|  if (conv.has_alt_flag() &&
  ------------------
  |  Branch (259:7): [True: 0, False: 256]
  ------------------
  260|      0|      conv.conversion_char() == FormatConversionCharInternal::o) {
  ------------------
  |  Branch (260:7): [True: 0, False: 0]
  ------------------
  261|       |    // From POSIX description of the '#' (alt) flag:
  262|       |    //   "For o conversion, it increases the precision (if necessary) to
  263|       |    //   force the first digit of the result to be zero."
  264|      0|    if (formatted.empty() || *formatted.begin() != '0') {
  ------------------
  |  Branch (264:9): [True: 0, False: 0]
  |  Branch (264:30): [True: 0, False: 0]
  ------------------
  265|      0|      size_t needed = formatted.size() + 1;
  266|      0|      precision = std::max(precision, needed);
  267|      0|    }
  268|      0|  }
  269|       |
  270|    256|  size_t num_zeroes = Excess(formatted.size(), precision);
  271|    256|  ReducePadding(num_zeroes, &fill);
  272|       |
  273|    256|  size_t num_left_spaces = !conv.has_left_flag() ? fill : 0;
  ------------------
  |  Branch (273:28): [True: 256, False: 0]
  ------------------
  274|    256|  size_t num_right_spaces = conv.has_left_flag() ? fill : 0;
  ------------------
  |  Branch (274:29): [True: 0, False: 256]
  ------------------
  275|       |
  276|       |  // From POSIX description of the '0' (zero) flag:
  277|       |  //   "For d, i, o, u, x, and X conversion specifiers, if a precision
  278|       |  //   is specified, the '0' flag is ignored."
  279|    256|  if (!precision_specified && conv.has_zero_flag()) {
  ------------------
  |  Branch (279:7): [True: 256, False: 0]
  |  Branch (279:31): [True: 256, False: 0]
  ------------------
  280|    256|    num_zeroes += num_left_spaces;
  281|    256|    num_left_spaces = 0;
  282|    256|  }
  283|       |
  284|    256|  sink->Append(num_left_spaces, ' ');
  285|    256|  sink->Append(sign);
  286|    256|  sink->Append(base_indicator);
  287|    256|  sink->Append(num_zeroes, '0');
  288|    256|  sink->Append(formatted);
  289|    256|  sink->Append(num_right_spaces, ' ');
  290|    256|  return true;
  291|    256|}
arg.cc:_ZNK4absl12lts_2026081719str_format_internal12_GLOBAL__N_19IntDigits19without_neg_or_zeroEv:
  179|    256|  string_view without_neg_or_zero() const {
  180|    256|    static_assert('-' < '0', "The check below verifies both.");
  181|    256|    size_t advance = start_[0] <= '0' ? 1 : 0;
  ------------------
  |  Branch (181:22): [True: 1, False: 255]
  ------------------
  182|    256|    return {start_ + advance, size_ - advance};
  183|    256|  }
arg.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_113ReducePaddingENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPm:
   49|    768|void ReducePadding(string_view s, size_t *capacity) {
   50|    768|  *capacity = Excess(s.size(), *capacity);
   51|    768|}
arg.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_110SignColumnEbNS1_24FormatConversionSpecImplE:
  214|    256|string_view SignColumn(bool neg, const FormatConversionSpecImpl conv) {
  215|    256|  if (conv.conversion_char() == FormatConversionCharInternal::d ||
  ------------------
  |  Branch (215:7): [True: 0, False: 256]
  ------------------
  216|    256|      conv.conversion_char() == FormatConversionCharInternal::i) {
  ------------------
  |  Branch (216:7): [True: 0, False: 256]
  ------------------
  217|      0|    if (neg) return "-";
  ------------------
  |  Branch (217:9): [True: 0, False: 0]
  ------------------
  218|      0|    if (conv.has_show_pos_flag()) return "+";
  ------------------
  |  Branch (218:9): [True: 0, False: 0]
  ------------------
  219|      0|    if (conv.has_sign_col_flag()) return " ";
  ------------------
  |  Branch (219:9): [True: 0, False: 0]
  ------------------
  220|      0|  }
  221|    256|  return {};
  222|    256|}
arg.cc:_ZNK4absl12lts_2026081719str_format_internal12_GLOBAL__N_19IntDigits11is_negativeEv:
  185|    256|  bool is_negative() const { return start_[0] == '-'; }
arg.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_113BaseIndicatorERKNS2_9IntDigitsENS1_24FormatConversionSpecImplE:
  197|    256|                          const FormatConversionSpecImpl conv) {
  198|       |  // always show 0x for %p.
  199|    256|  bool alt = conv.has_alt_flag() ||
  ------------------
  |  Branch (199:14): [True: 0, False: 256]
  ------------------
  200|    256|             conv.conversion_char() == FormatConversionCharInternal::p;
  ------------------
  |  Branch (200:14): [True: 0, False: 256]
  ------------------
  201|    256|  bool hex = (conv.conversion_char() == FormatConversionCharInternal::x ||
  ------------------
  |  Branch (201:15): [True: 0, False: 256]
  ------------------
  202|    256|              conv.conversion_char() == FormatConversionCharInternal::X ||
  ------------------
  |  Branch (202:15): [True: 256, False: 0]
  ------------------
  203|      0|              conv.conversion_char() == FormatConversionCharInternal::p);
  ------------------
  |  Branch (203:15): [True: 0, False: 0]
  ------------------
  204|       |  // From the POSIX description of '#' flag:
  205|       |  //   "For x or X conversion specifiers, a non-zero result shall have
  206|       |  //   0x (or 0X) prefixed to it."
  207|    256|  if (alt && hex && !as_digits.without_neg_or_zero().empty()) {
  ------------------
  |  Branch (207:7): [True: 0, False: 256]
  |  Branch (207:7): [True: 0, False: 256]
  |  Branch (207:14): [True: 0, False: 0]
  |  Branch (207:21): [True: 0, False: 0]
  ------------------
  208|      0|    return conv.conversion_char() == FormatConversionCharInternal::X ? "0X"
  ------------------
  |  Branch (208:12): [True: 0, False: 0]
  ------------------
  209|      0|                                                                     : "0x";
  210|      0|  }
  211|    256|  return {};
  212|    256|}
arg.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_19IntDigits15PrintAsHexUpperIjEEvT_:
  160|    256|  void PrintAsHexUpper(T v) {
  161|    256|    static_assert(!IsSigned<T>::value, "");
  162|    256|    char *p = storage_ + sizeof(storage_);
  163|       |
  164|       |    // kHexTable is only lowercase, so do it manually for uppercase.
  165|    496|    do {
  166|    496|      *--p = "0123456789ABCDEF"[static_cast<size_t>(v) & 15];
  167|    496|      v >>= 4;
  168|    496|    } while (v);
  ------------------
  |  Branch (168:14): [True: 240, False: 256]
  ------------------
  169|    256|    start_ = p;
  170|    256|    size_ = static_cast<size_t>(storage_ + sizeof(storage_) - p);
  171|    256|  }

_ZN4absl12lts_2026081719str_format_internal19FormatArgImplFriend7ConvertINS1_13FormatArgImplEEEbT_NS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  407|    256|                      FormatSinkImpl* out) {
  408|    256|    return arg.dispatcher_(arg.data_, conv, out);
  409|    256|  }

_ZN4absl12lts_2026081719str_format_internal13FormatUntypedENS1_17FormatRawSinkImplENS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  214|    256|                   absl::Span<const FormatArgImpl> args) {
  215|    256|  FormatSinkImpl sink(raw_sink);
  216|    256|  using Converter = DefaultConverter;
  217|    256|  return ConvertAll(format, args, Converter(&sink));
  218|    256|}
_ZN4absl12lts_2026081719str_format_internal10FormatPackENS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  235|    256|                       absl::Span<const FormatArgImpl> args) {
  236|    256|  std::string out;
  237|    256|  if (ABSL_PREDICT_FALSE(!FormatUntyped(&out, format, args))) {
  ------------------
  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  Branch (190:58): [True: 0, False: 256]
  |  |  ------------------
  ------------------
  238|      0|    out.clear();
  239|      0|  }
  240|    256|  return out;
  241|    256|}
bind.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_110ArgContextC2ENS0_4SpanIKNS1_13FormatArgImplEEE:
   55|    256|  explicit ArgContext(absl::Span<const FormatArgImpl> pack) : pack_(pack) {}
bind.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_110ArgContext4BindEPKNS1_17UnboundConversionEPNS1_15BoundConversionE:
   70|    256|                             BoundConversion* bound) {
   71|    256|  const FormatArgImpl* arg = nullptr;
   72|    256|  int arg_position = unbound->arg_position;
   73|    256|  if (static_cast<size_t>(arg_position - 1) >= pack_.size()) return false;
  ------------------
  |  Branch (73:7): [True: 0, False: 256]
  ------------------
   74|    256|  arg = &pack_[static_cast<size_t>(arg_position - 1)];  // 1-based
   75|       |
   76|    256|  if (unbound->flags != Flags::kBasic) {
  ------------------
  |  Branch (76:7): [True: 256, False: 0]
  ------------------
   77|    256|    int width = unbound->width.value();
   78|    256|    bool force_left = false;
   79|    256|    if (unbound->width.is_from_arg()) {
  ------------------
  |  Branch (79:9): [True: 0, False: 256]
  ------------------
   80|      0|      if (!BindFromPosition(unbound->width.get_from_arg(), &width, pack_))
  ------------------
  |  Branch (80:11): [True: 0, False: 0]
  ------------------
   81|      0|        return false;
   82|      0|      if (width < 0) {
  ------------------
  |  Branch (82:11): [True: 0, False: 0]
  ------------------
   83|       |        // "A negative field width is taken as a '-' flag followed by a
   84|       |        // positive field width."
   85|      0|        force_left = true;
   86|       |        // Make sure we don't overflow the width when negating it.
   87|      0|        width = -std::max(width, -std::numeric_limits<int>::max());
   88|      0|      }
   89|      0|    }
   90|       |
   91|    256|    int precision = unbound->precision.value();
   92|    256|    if (unbound->precision.is_from_arg()) {
  ------------------
  |  Branch (92:9): [True: 0, False: 256]
  ------------------
   93|      0|      if (!BindFromPosition(unbound->precision.get_from_arg(), &precision,
  ------------------
  |  Branch (93:11): [True: 0, False: 0]
  ------------------
   94|      0|                            pack_))
   95|      0|        return false;
   96|      0|    }
   97|       |
   98|    256|    FormatConversionSpecImplFriend::SetWidth(width, bound);
   99|    256|    FormatConversionSpecImplFriend::SetPrecision(precision, bound);
  100|       |
  101|    256|    if (force_left) {
  ------------------
  |  Branch (101:9): [True: 0, False: 256]
  ------------------
  102|      0|      FormatConversionSpecImplFriend::SetFlags(unbound->flags | Flags::kLeft,
  103|      0|                                               bound);
  104|    256|    } else {
  105|    256|      FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
  106|    256|    }
  107|       |
  108|    256|    FormatConversionSpecImplFriend::SetLengthMod(unbound->length_mod, bound);
  109|    256|  } else {
  110|      0|    FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
  111|      0|    FormatConversionSpecImplFriend::SetWidth(-1, bound);
  112|      0|    FormatConversionSpecImplFriend::SetPrecision(-1, bound);
  113|      0|  }
  114|    256|  FormatConversionSpecImplFriend::SetConversionChar(unbound->conv, bound);
  115|    256|  bound->set_arg(arg);
  116|    256|  return true;
  117|    256|}
bind.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_116DefaultConverterC2EPNS1_14FormatSinkImplE:
  154|    256|  explicit DefaultConverter(FormatSinkImpl* sink) : sink_(sink) {}
bind.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_110ConvertAllINS2_16DefaultConverterEEEbNS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEET_:
  142|    256|                absl::Span<const FormatArgImpl> args, Converter converter) {
  143|    256|  if (format.has_parsed_conversion()) {
  ------------------
  |  Branch (143:7): [True: 0, False: 256]
  ------------------
  144|      0|    return format.parsed_conversion()->ProcessFormat(
  145|      0|        ConverterConsumer<Converter>(converter, args));
  146|    256|  } else {
  147|    256|    return ParseFormatString(format.str(),
  148|    256|                             ConverterConsumer<Converter>(converter, args));
  149|    256|  }
  150|    256|}
bind.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEE10ConvertOneERKNS1_17UnboundConversionENSt3__117basic_string_viewIcNS9_11char_traitsIcEEEE:
  129|    256|  bool ConvertOne(const UnboundConversion& conv, string_view conv_string) {
  130|    256|    BoundConversion bound;
  131|    256|    if (!arg_context_.Bind(&conv, &bound)) return false;
  ------------------
  |  Branch (131:9): [True: 0, False: 256]
  ------------------
  132|    256|    return converter_.ConvertOne(bound, conv_string);
  133|    256|  }
bind.cc:_ZNK4absl12lts_2026081719str_format_internal12_GLOBAL__N_116DefaultConverter10ConvertOneERKNS1_15BoundConversionENSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
  158|    256|  bool ConvertOne(const BoundConversion& bound, string_view /*conv*/) const {
  159|    256|    return FormatArgImplFriend::Convert(*bound.arg(), bound, sink_);
  160|    256|  }
bind.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEE6AppendENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
  125|    512|  bool Append(string_view s) {
  126|    512|    converter_.Append(s);
  127|    512|    return true;
  128|    512|  }
bind.cc:_ZNK4absl12lts_2026081719str_format_internal12_GLOBAL__N_116DefaultConverter6AppendENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  156|    512|  void Append(string_view s) const { sink_->Append(s); }
bind.cc:_ZN4absl12lts_2026081719str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEEC2ES4_NS0_4SpanIKNS1_13FormatArgImplEEE:
  123|    256|      : converter_(converter), arg_context_(pack) {}

_ZNK4absl12lts_2026081719str_format_internal15BoundConversion3argEv:
   43|    256|  const FormatArgImpl* arg() const { return arg_; }
_ZN4absl12lts_2026081719str_format_internal15BoundConversion7set_argEPKNS1_13FormatArgImplE:
   44|    256|  void set_arg(const FormatArgImpl* a) { arg_ = a; }
_ZNK4absl12lts_2026081719str_format_internal21UntypedFormatSpecImpl21has_parsed_conversionEv:
   61|    256|  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
_ZNK4absl12lts_2026081719str_format_internal21UntypedFormatSpecImpl3strEv:
   63|    256|  string_view str() const {
   64|       |    assert(!has_parsed_conversion());
   65|    256|    return string_view(static_cast<const char*>(data_), size_);
   66|    256|  }

_ZN4absl12lts_2026081719str_format_internal17UnboundConversionC2Ev:
   36|    256|  UnboundConversion() {}  // NOLINT
_ZN4absl12lts_2026081719str_format_internal17UnboundConversion10InputValue9set_valueEi:
   45|    256|    constexpr void set_value(int value) {
   46|       |      assert(value >= 0);
   47|    256|      value_ = value;
   48|    256|    }
_ZNK4absl12lts_2026081719str_format_internal17UnboundConversion10InputValue5valueEv:
   49|    512|    constexpr int value() const { return value_; }
_ZNK4absl12lts_2026081719str_format_internal17UnboundConversion10InputValue11is_from_argEv:
   60|    512|    constexpr bool is_from_arg() const { return value_ < -1; }
_ZNK4absl12lts_2026081719str_format_internal7ConvTag7is_convEv:
   94|    512|  constexpr bool is_conv() const { return (tag_ & 0x80) == 0; }
_ZNK4absl12lts_2026081719str_format_internal7ConvTag8is_flagsEv:
   96|    256|  constexpr bool is_flags() const { return (tag_ & 0xE0) == 0xC0; }
_ZNK4absl12lts_2026081719str_format_internal7ConvTag7as_convEv:
   98|    256|  constexpr FormatConversionChar as_conv() const {
   99|    256|    assert(is_conv());
  100|    256|    assert(!is_length());
  101|       |    assert(!is_flags());
  102|    256|    return static_cast<FormatConversionChar>(tag_);
  103|    256|  }
_ZNK4absl12lts_2026081719str_format_internal7ConvTag8as_flagsEv:
  110|    256|  constexpr Flags as_flags() const {
  111|    256|    assert(!is_conv());
  112|    256|    assert(!is_length());
  113|       |    assert(is_flags());
  114|    256|    return static_cast<Flags>(tag_ & 0x1F);
  115|    256|  }
_ZN4absl12lts_2026081719str_format_internal17ConsumeConversionILb0EEEPKcS4_S4_PNS1_17UnboundConversionEPi:
  216|    256|                                        int* next_arg) {
  217|    256|  const char* const original_pos = pos;
  218|    256|  char c = 0;
  219|       |  // Read the next char into `c` and update `pos`. Returns false if there are
  220|       |  // no more chars to read.
  221|    256|#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR()          \
  222|    256|  do {                                                  \
  223|    256|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  224|    256|    c = *pos++;                                         \
  225|    256|  } while (0)
  226|       |
  227|    256|  if (is_positional) {
  ------------------
  |  Branch (227:7): [Folded, False: 256]
  ------------------
  228|      0|    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  229|      0|    if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  230|      0|    conv->arg_position = ParseDigits(c, pos, end);
  231|      0|    assert(conv->arg_position > 0);
  232|      0|    if (ABSL_PREDICT_FALSE(c != '$')) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  233|      0|  }
  234|       |
  235|    256|  ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|    256|  do {                                                  \
  |  |  223|    256|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 256]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|    256|    c = *pos++;                                         \
  |  |  225|    256|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 256]
  |  |  ------------------
  ------------------
  236|       |
  237|       |  // We should start with the basic flag on.
  238|    256|  assert(conv->flags == Flags::kBasic);
  239|       |
  240|       |  // Any non alpha character makes this conversion not basic.
  241|       |  // This includes flags (-+ #0), width (1-9, *) or precision (.).
  242|       |  // All conversion characters and length modifiers are alpha characters.
  243|    256|  if (c < 'A') {
  ------------------
  |  Branch (243:7): [True: 256, False: 0]
  ------------------
  244|    512|    while (c <= '0') {
  ------------------
  |  Branch (244:12): [True: 256, False: 256]
  ------------------
  245|    256|      auto tag = GetTagForChar(c);
  246|    256|      if (tag.is_flags()) {
  ------------------
  |  Branch (246:11): [True: 256, False: 0]
  ------------------
  247|    256|        conv->flags = conv->flags | tag.as_flags();
  248|    256|        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|    256|  do {                                                  \
  |  |  223|    256|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 256]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|    256|    c = *pos++;                                         \
  |  |  225|    256|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 256]
  |  |  ------------------
  ------------------
  249|    256|      } else {
  250|      0|        break;
  251|      0|      }
  252|    256|    }
  253|       |
  254|    256|    if (c <= '9') {
  ------------------
  |  Branch (254:9): [True: 256, False: 0]
  ------------------
  255|    256|      if (c >= '0') {
  ------------------
  |  Branch (255:11): [True: 256, False: 0]
  ------------------
  256|    256|        int maybe_width = ParseDigits(c, pos, end);
  257|    256|        if (!is_positional && c == '$') {
  ------------------
  |  Branch (257:13): [True: 256, Folded]
  |  Branch (257:31): [True: 0, False: 256]
  ------------------
  258|      0|          if (ABSL_PREDICT_FALSE(*next_arg != 0)) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  259|       |          // Positional conversion.
  260|      0|          *next_arg = -1;
  261|      0|          return ConsumeConversion<true>(original_pos, end, conv, next_arg);
  262|      0|        }
  263|    256|        conv->flags = conv->flags | Flags::kNonBasic;
  264|    256|        conv->width.set_value(maybe_width);
  265|    256|      } else if (c == '*') {
  ------------------
  |  Branch (265:18): [True: 0, False: 0]
  ------------------
  266|      0|        conv->flags = conv->flags | Flags::kNonBasic;
  267|      0|        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  268|      0|        if (is_positional) {
  ------------------
  |  Branch (268:13): [Folded, False: 0]
  ------------------
  269|      0|          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  270|      0|          conv->width.set_from_arg(ParseDigits(c, pos, end));
  271|      0|          if (ABSL_PREDICT_FALSE(c != '$')) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  272|      0|          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  273|      0|        } else {
  274|      0|          conv->width.set_from_arg(++*next_arg);
  275|      0|        }
  276|      0|      }
  277|    256|    }
  278|       |
  279|    256|    if (c == '.') {
  ------------------
  |  Branch (279:9): [True: 0, False: 256]
  ------------------
  280|      0|      conv->flags = conv->flags | Flags::kNonBasic;
  281|      0|      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  282|      0|      if ('0' <= c && c <= '9') {
  ------------------
  |  Branch (282:11): [True: 0, False: 0]
  |  Branch (282:23): [True: 0, False: 0]
  ------------------
  283|      0|        conv->precision.set_value(ParseDigits(c, pos, end));
  284|      0|      } else if (c == '*') {
  ------------------
  |  Branch (284:18): [True: 0, False: 0]
  ------------------
  285|      0|        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  286|      0|        if (is_positional) {
  ------------------
  |  Branch (286:13): [Folded, False: 0]
  ------------------
  287|      0|          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  288|      0|          conv->precision.set_from_arg(ParseDigits(c, pos, end));
  289|      0|          if (c != '$') return nullptr;
  ------------------
  |  Branch (289:15): [True: 0, False: 0]
  ------------------
  290|      0|          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  291|      0|        } else {
  292|      0|          conv->precision.set_from_arg(++*next_arg);
  293|      0|        }
  294|      0|      } else {
  295|      0|        conv->precision.set_value(0);
  296|      0|      }
  297|      0|    }
  298|    256|  }
  299|       |
  300|    256|  auto tag = GetTagForChar(c);
  301|       |
  302|    256|  if (ABSL_PREDICT_FALSE(c == 'v' && conv->flags != Flags::kBasic)) {
  ------------------
  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  Branch (190:59): [True: 0, False: 256]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  303|      0|    return nullptr;
  304|      0|  }
  305|       |
  306|    256|  if (ABSL_PREDICT_FALSE(!tag.is_conv())) {
  ------------------
  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  Branch (190:58): [True: 0, False: 256]
  |  |  ------------------
  ------------------
  307|      0|    if (ABSL_PREDICT_FALSE(!tag.is_length())) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  308|       |
  309|       |    // It is a length modifier.
  310|      0|    LengthMod length_mod = tag.as_length();
  311|      0|    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  312|      0|    if (c == 'h' && length_mod == LengthMod::h) {
  ------------------
  |  Branch (312:9): [True: 0, False: 0]
  |  Branch (312:21): [True: 0, False: 0]
  ------------------
  313|      0|      conv->length_mod = LengthMod::hh;
  314|      0|      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  315|      0|    } else if (c == 'l' && length_mod == LengthMod::l) {
  ------------------
  |  Branch (315:16): [True: 0, False: 0]
  |  Branch (315:28): [True: 0, False: 0]
  ------------------
  316|      0|      conv->length_mod = LengthMod::ll;
  317|      0|      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  318|      0|    } else {
  319|      0|      conv->length_mod = length_mod;
  320|      0|    }
  321|      0|    tag = GetTagForChar(c);
  322|       |
  323|      0|    if (ABSL_PREDICT_FALSE(c == 'v')) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  324|      0|    if (ABSL_PREDICT_FALSE(!tag.is_conv())) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  325|       |
  326|       |    // `wchar_t` args are marked non-basic so `Bind()` will copy the length mod.
  327|      0|    if (conv->length_mod == LengthMod::l && c == 'c') {
  ------------------
  |  Branch (327:9): [True: 0, False: 0]
  |  Branch (327:45): [True: 0, False: 0]
  ------------------
  328|      0|      conv->flags = conv->flags | Flags::kNonBasic;
  329|      0|    }
  330|      0|  }
  331|    256|#undef ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR
  332|       |
  333|    256|  assert(CheckFastPathSetting(*conv));
  334|    256|  (void)(&CheckFastPathSetting);
  335|       |
  336|    256|  conv->conv = tag.as_conv();
  337|    256|  if (!is_positional) conv->arg_position = ++*next_arg;
  ------------------
  |  Branch (337:7): [True: 256, Folded]
  ------------------
  338|    256|  return pos;
  339|    256|}
_ZN4absl12lts_2026081719str_format_internal13GetTagForCharEc:
  169|    768|constexpr ConvTag GetTagForChar(char c) {
  170|    768|  return ConvTagHolder::value[static_cast<unsigned char>(c)];
  171|    768|}
_ZN4absl12lts_2026081719str_format_internal11ParseDigitsERcRPKcS4_:
  196|    256|constexpr int ParseDigits(char& c, const char*& pos, const char* const end) {
  197|    256|  int digits = c - '0';
  198|       |  // We do not want to overflow `digits` so we consume at most digits10
  199|       |  // digits. If there are more digits the parsing will fail later on when the
  200|       |  // digit doesn't match the expected characters.
  201|    256|  int num_digits = std::numeric_limits<int>::digits10;
  202|    256|  for (;;) {
  203|    256|    if (ABSL_PREDICT_FALSE(pos == end)) break;
  ------------------
  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  Branch (190:58): [True: 0, False: 256]
  |  |  ------------------
  ------------------
  204|    256|    c = *pos++;
  205|    256|    if ('0' > c || c > '9') break;
  ------------------
  |  Branch (205:9): [True: 0, False: 256]
  |  Branch (205:20): [True: 256, False: 0]
  ------------------
  206|      0|    --num_digits;
  207|      0|    if (ABSL_PREDICT_FALSE(!num_digits)) break;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  208|      0|    digits = 10 * digits + c - '0';
  209|      0|  }
  210|    256|  return digits;
  211|    256|}
_ZN4absl12lts_2026081719str_format_internal24ConsumeUnboundConversionEPKcS3_PNS1_17UnboundConversionEPi:
  348|    256|                                               int* next_arg) {
  349|    256|  if (*next_arg < 0) return ConsumeConversion<true>(p, end, conv, next_arg);
  ------------------
  |  Branch (349:7): [True: 0, False: 256]
  ------------------
  350|    256|  return ConsumeConversion<false>(p, end, conv, next_arg);
  351|    256|}

_ZN4absl12lts_2026081719str_format_internal17FormatRawSinkImpl5WriteENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   48|    256|  void Write(string_view s) { write_(sink_, s); }
_ZN4absl12lts_2026081719str_format_internal14FormatSinkImplC2ENS1_17FormatRawSinkImplE:
   68|    256|  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
_ZN4absl12lts_2026081719str_format_internal14FormatSinkImplD2Ev:
   70|    256|  ~FormatSinkImpl() { Flush(); }
_ZN4absl12lts_2026081719str_format_internal14FormatSinkImpl5FlushEv:
   72|    256|  void Flush() {
   73|    256|    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
   74|    256|    pos_ = buf_;
   75|    256|  }
_ZN4absl12lts_2026081719str_format_internal14FormatSinkImpl6AppendEmc:
   77|    768|  void Append(size_t n, char c) {
   78|    768|    if (n == 0) return;
  ------------------
  |  Branch (78:9): [True: 752, False: 16]
  ------------------
   79|     16|    size_ += n;
   80|     16|    auto raw_append = [&](size_t count) {
   81|     16|      memset(pos_, c, count);
   82|     16|      pos_ += count;
   83|     16|    };
   84|     16|    while (n > Avail()) {
  ------------------
  |  Branch (84:12): [True: 0, False: 16]
  ------------------
   85|      0|      n -= Avail();
   86|      0|      if (Avail() > 0) {
  ------------------
  |  Branch (86:11): [True: 0, False: 0]
  ------------------
   87|      0|        raw_append(Avail());
   88|      0|      }
   89|      0|      Flush();
   90|      0|    }
   91|     16|    raw_append(n);
   92|     16|  }
_ZN4absl12lts_2026081719str_format_internal14FormatSinkImpl6AppendENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   94|  1.28k|  void Append(string_view v) {
   95|  1.28k|    size_t n = v.size();
   96|  1.28k|    if (n == 0) return;
  ------------------
  |  Branch (96:9): [True: 513, False: 767]
  ------------------
   97|    767|    size_ += n;
   98|    767|    if (n >= Avail()) {
  ------------------
  |  Branch (98:9): [True: 0, False: 767]
  ------------------
   99|      0|      Flush();
  100|      0|      raw_.Write(v);
  101|      0|      return;
  102|      0|    }
  103|    767|    memcpy(pos_, v.data(), n);
  104|    767|    pos_ += n;
  105|    767|  }
_ZNK4absl12lts_2026081719str_format_internal14FormatSinkImpl5AvailEv:
  123|    783|  size_t Avail() const {
  124|    783|    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
  125|    783|  }
_ZNK4absl12lts_2026081719str_format_internal24FormatConversionSpecImpl8is_basicEv:
  277|    256|  bool is_basic() const { return flags_ == Flags::kBasic; }
_ZNK4absl12lts_2026081719str_format_internal24FormatConversionSpecImpl13has_left_flagEv:
  278|    512|  bool has_left_flag() const { return FlagsContains(flags_, Flags::kLeft); }
_ZNK4absl12lts_2026081719str_format_internal24FormatConversionSpecImpl12has_alt_flagEv:
  285|    512|  bool has_alt_flag() const { return FlagsContains(flags_, Flags::kAlt); }
_ZNK4absl12lts_2026081719str_format_internal24FormatConversionSpecImpl13has_zero_flagEv:
  286|    256|  bool has_zero_flag() const { return FlagsContains(flags_, Flags::kZero); }
_ZNK4absl12lts_2026081719str_format_internal24FormatConversionSpecImpl5widthEv:
  301|    512|  int width() const { return width_; }
_ZNK4absl12lts_2026081719str_format_internal24FormatConversionSpecImpl9precisionEv:
  304|    256|  int precision() const { return precision_; }
_ZN4absl12lts_2026081719str_format_internal30FormatConversionSpecImplFriend8SetFlagsENS1_5FlagsEPNS1_24FormatConversionSpecImplE:
  321|    256|  static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
  322|    256|    conv->flags_ = f;
  323|    256|  }
_ZN4absl12lts_2026081719str_format_internal30FormatConversionSpecImplFriend12SetLengthModENS0_9LengthModEPNS1_24FormatConversionSpecImplE:
  324|    256|  static void SetLengthMod(LengthMod l, FormatConversionSpecImpl* conv) {
  325|    256|    conv->length_mod_ = l;
  326|    256|  }
_ZN4absl12lts_2026081719str_format_internal30FormatConversionSpecImplFriend17SetConversionCharENS0_20FormatConversionCharEPNS1_24FormatConversionSpecImplE:
  328|    256|                                FormatConversionSpecImpl* conv) {
  329|    256|    conv->conv_ = c;
  330|    256|  }
_ZN4absl12lts_2026081719str_format_internal30FormatConversionSpecImplFriend8SetWidthEiPNS1_24FormatConversionSpecImplE:
  331|    256|  static void SetWidth(int w, FormatConversionSpecImpl* conv) {
  332|    256|    conv->width_ = w;
  333|    256|  }
_ZN4absl12lts_2026081719str_format_internal30FormatConversionSpecImplFriend12SetPrecisionEiPNS1_24FormatConversionSpecImplE:
  334|    256|  static void SetPrecision(int p, FormatConversionSpecImpl* conv) {
  335|    256|    conv->precision_ = p;
  336|    256|  }
_ZN4absl12lts_2026081719str_format_internalorENS1_5FlagsES2_:
  146|    512|constexpr Flags operator|(Flags a, Flags b) {
  147|    512|  return static_cast<Flags>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
  148|    512|}
_ZN4absl12lts_2026081719str_format_internal13FlagsContainsENS1_5FlagsES2_:
  150|  1.28k|constexpr bool FlagsContains(Flags haystack, Flags needle) {
  151|  1.28k|  return (static_cast<uint8_t>(haystack) & static_cast<uint8_t>(needle)) ==
  152|  1.28k|         static_cast<uint8_t>(needle);
  153|  1.28k|}
_ZN4absl12lts_2026081719str_format_internal6ExcessEmm:
  447|  1.28k|inline size_t Excess(size_t used, size_t capacity) {
  448|  1.28k|  return used < capacity ? capacity - used : 0;
  ------------------
  |  Branch (448:10): [True: 65, False: 1.21k]
  ------------------
  449|  1.28k|}
_ZZN4absl12lts_2026081719str_format_internal14FormatSinkImpl6AppendEmcENKUlmE_clEm:
   80|     16|    auto raw_append = [&](size_t count) {
   81|     16|      memset(pos_, c, count);
   82|     16|      pos_ += count;
   83|     16|    };
_ZN4absl12lts_2026081719str_format_internal17FormatRawSinkImplC2INSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETnPDTclsr19str_format_internalE11InvokeFlushclsr3stdE7declvalIPT_EEcvNS4_17basic_string_viewIcS7_EE_EEELPv0EEESC_:
   46|    256|      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
_ZN4absl12lts_2026081719str_format_internal17FormatRawSinkImpl5FlushINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvPvNS4_17basic_string_viewIcS7_EE:
   57|    256|  static void Flush(void* r, string_view s) {
   58|    256|    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
   59|    256|  }

_ZN4absl12lts_2026081719str_format_internal15AbslFormatFlushEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EE:
   71|    256|inline void AbslFormatFlush(std::string* out, string_view s) {
   72|    256|  out->append(s.data(), s.size());
   73|    256|}
_ZN4absl12lts_2026081719str_format_internal11InvokeFlushINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEDTcl15AbslFormatFlushfp_fp0_EEPT_NS3_17basic_string_viewIcS6_EE:
   89|    256|auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
   90|    256|  AbslFormatFlush(out, s);
   91|    256|}

_ZN4absl12lts_2026081719str_format_internal32ConsumeUnboundConversionNoInlineEPKcS3_PNS1_17UnboundConversionEPi:
   38|    256|    const char* p, const char* end, UnboundConversion* conv, int* next_arg) {
   39|    256|  return ConsumeUnboundConversion(p, end, conv, next_arg);
   40|    256|}

bind.cc:_ZN4absl12lts_2026081719str_format_internal17ParseFormatStringINS1_12_GLOBAL__N_117ConverterConsumerINS3_16DefaultConverterEEEEEbNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEET_:
   57|    256|bool ParseFormatString(string_view src, Consumer consumer) {
   58|    256|  int next_arg = 0;
   59|    256|  const char* p = src.data();
   60|    256|  const char* const end = p + src.size();
   61|    512|  while (p != end) {
  ------------------
  |  Branch (61:10): [True: 512, False: 0]
  ------------------
   62|    512|    const char* percent =
   63|    512|        static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
   64|    512|    if (!percent) {
  ------------------
  |  Branch (64:9): [True: 256, False: 256]
  ------------------
   65|       |      // We found the last substring.
   66|    256|      return consumer.Append(string_view(p, static_cast<size_t>(end - p)));
   67|    256|    }
   68|       |    // We found a percent, so push the text run then process the percent.
   69|    256|    if (ABSL_PREDICT_FALSE(!consumer.Append(
  ------------------
  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  Branch (190:58): [True: 0, False: 256]
  |  |  ------------------
  ------------------
   70|    256|            string_view(p, static_cast<size_t>(percent - p))))) {
   71|      0|      return false;
   72|      0|    }
   73|    256|    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
  ------------------
  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  Branch (190:58): [True: 0, False: 256]
  |  |  ------------------
  ------------------
   74|       |
   75|    256|    auto tag = GetTagForChar(percent[1]);
   76|    256|    if (tag.is_conv()) {
  ------------------
  |  Branch (76:9): [True: 0, False: 256]
  ------------------
   77|      0|      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   78|       |        // This indicates an error in the format string.
   79|       |        // The only way to get `next_arg < 0` here is to have a positional
   80|       |        // argument first which sets next_arg to -1 and then a non-positional
   81|       |        // argument.
   82|      0|        return false;
   83|      0|      }
   84|      0|      p = percent + 2;
   85|       |
   86|       |      // Keep this case separate from the one below.
   87|       |      // ConvertOne is more efficient when the compiler can see that the `basic`
   88|       |      // flag is set.
   89|      0|      UnboundConversion conv;
   90|      0|      conv.conv = tag.as_conv();
   91|      0|      conv.arg_position = ++next_arg;
   92|      0|      if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   93|      0|              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
   94|      0|        return false;
   95|      0|      }
   96|    256|    } else if (percent[1] != '%') {
  ------------------
  |  Branch (96:16): [True: 256, False: 0]
  ------------------
   97|    256|      UnboundConversion conv;
   98|    256|      p = ConsumeUnboundConversionNoInline(percent + 1, end, &conv, &next_arg);
   99|    256|      if (ABSL_PREDICT_FALSE(p == nullptr)) return false;
  ------------------
  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  Branch (190:58): [True: 0, False: 256]
  |  |  ------------------
  ------------------
  100|    256|      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
  ------------------
  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  Branch (190:58): [True: 0, False: 256]
  |  |  ------------------
  ------------------
  101|    256|              conv, string_view(percent + 1,
  102|    256|                                static_cast<size_t>(p - (percent + 1)))))) {
  103|      0|        return false;
  104|      0|      }
  105|    256|    } else {
  106|      0|      if (ABSL_PREDICT_FALSE(!consumer.Append("%"))) return false;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  107|      0|      p = percent + 2;
  108|      0|      continue;
  109|      0|    }
  110|    256|  }
  111|      0|  return true;
  112|    256|}

_ZN4absl12lts_2026081724synchronization_internal14InvalidGraphIdEv:
   58|      4|inline GraphId InvalidGraphId() {
   59|      4|  return GraphId{0};
   60|      4|}

_ZN4absl12lts_202608175Mutex4lockEv:
 1538|      4|void Mutex::lock() {
 1539|      4|  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
 1540|      4|  GraphId id = DebugOnlyDeadlockCheck(this);
 1541|      4|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1542|       |  // try fast acquire, then spin loop
 1543|      4|  if (ABSL_PREDICT_FALSE((v & (kMuWriter | kMuReader | kMuEvent)) != 0) ||
  ------------------
  |  |  190|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 4]
  |  |  |  Branch (190:49): [Folded, False: 4]
  |  |  |  Branch (190:58): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 1544|      4|      ABSL_PREDICT_FALSE(!mu_.compare_exchange_strong(
  ------------------
  |  |  190|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 4]
  |  |  |  Branch (190:49): [Folded, False: 4]
  |  |  |  Branch (190:58): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 1545|      4|          v, kMuWriter | v, std::memory_order_acquire,
 1546|      4|          std::memory_order_relaxed))) {
 1547|       |    // try spin acquire, then slow loop
 1548|      0|    if (ABSL_PREDICT_FALSE(!TryAcquireWithSpinning(&this->mu_))) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1549|      0|      this->LockSlow(kExclusive, nullptr, 0);
 1550|      0|    }
 1551|      0|  }
 1552|      4|  DebugOnlyLockEnter(this, id);
 1553|      4|  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 1554|      4|}
_ZN4absl12lts_202608175Mutex6unlockEv:
 1716|      4|void Mutex::unlock() {
 1717|      4|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
 1718|      4|  DebugOnlyLockLeave(this);
 1719|      4|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1720|       |
 1721|      4|  if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) {
  ------------------
  |  Branch (1721:7): [Folded, False: 4]
  |  Branch (1721:21): [True: 0, False: 0]
  ------------------
 1722|      0|    ABSL_RAW_LOG(FATAL, "Mutex unlocked when destroyed or not locked: v=0x%x",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL 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]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1723|      0|                 static_cast<unsigned>(v));
 1724|      0|  }
 1725|       |
 1726|       |  // should_try_cas is whether we'll try a compare-and-swap immediately.
 1727|       |  // NOTE: optimized out when kDebugMode is false.
 1728|      4|  bool should_try_cas = ((v & (kMuEvent | kMuWriter)) == kMuWriter &&
  ------------------
  |  Branch (1728:26): [True: 4, False: 0]
  ------------------
 1729|      4|                         (v & (kMuWait | kMuDesig)) != kMuWait);
  ------------------
  |  Branch (1729:26): [True: 4, False: 0]
  ------------------
 1730|       |
 1731|       |  // But, we can use an alternate computation of it, that compilers
 1732|       |  // currently don't find on their own.  When that changes, this function
 1733|       |  // can be simplified.
 1734|       |  //
 1735|       |  // should_try_cas is true iff the bits satisfy the following conditions:
 1736|       |  //
 1737|       |  //                   Ev Wr Wa De
 1738|       |  // equal to           0  1
 1739|       |  // and not equal to         1  0
 1740|       |  //
 1741|       |  // after xoring by    0  1  0  1,  this is equivalent to:
 1742|       |  //
 1743|       |  // equal to           0  0
 1744|       |  // and not equal to         1  1,  which is the same as:
 1745|       |  //
 1746|       |  // smaller than       0  0  1  1
 1747|      4|  static_assert(kMuEvent > kMuWait, "Needed for should_try_cas_fast");
 1748|      4|  static_assert(kMuEvent > kMuDesig, "Needed for should_try_cas_fast");
 1749|      4|  static_assert(kMuWriter > kMuWait, "Needed for should_try_cas_fast");
 1750|      4|  static_assert(kMuWriter > kMuDesig, "Needed for should_try_cas_fast");
 1751|       |
 1752|      4|  bool should_try_cas_fast =
 1753|      4|      ((v ^ (kMuWriter | kMuDesig)) &
 1754|      4|       (kMuEvent | kMuWriter | kMuWait | kMuDesig)) < (kMuWait | kMuDesig);
 1755|       |
 1756|      4|  if (kDebugMode && should_try_cas != should_try_cas_fast) {
  ------------------
  |  Branch (1756:7): [Folded, False: 4]
  |  Branch (1756:21): [True: 0, False: 0]
  ------------------
 1757|       |    // We would usually use PRIdPTR here, but is not correctly implemented
 1758|       |    // within the android toolchain.
 1759|      0|    ABSL_RAW_LOG(FATAL, "internal logic error %llx %llx %llx\n",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL 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]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1760|      0|                 static_cast<long long>(v),
 1761|      0|                 static_cast<long long>(should_try_cas),
 1762|      0|                 static_cast<long long>(should_try_cas_fast));
 1763|      0|  }
 1764|      4|  if (should_try_cas_fast &&
  ------------------
  |  Branch (1764:7): [True: 4, False: 0]
  ------------------
 1765|      4|      mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
  ------------------
  |  Branch (1765:7): [True: 4, False: 0]
  ------------------
 1766|      4|                                  std::memory_order_release,
 1767|      4|                                  std::memory_order_relaxed)) {
 1768|       |    // fast writer release (writer with no waiters or with designated waker)
 1769|      4|  } else {
 1770|      0|    this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
 1771|      0|  }
 1772|      4|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
 1773|      4|}
mutex.cc:_ZN4absl12lts_20260817L22DebugOnlyDeadlockCheckEPNS0_5MutexE:
 1480|      4|static inline GraphId DebugOnlyDeadlockCheck(Mutex* mu) {
 1481|      4|  if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1481:7): [Folded, False: 4]
  |  Branch (1481:21): [True: 0, False: 0]
  ------------------
 1482|      0|                        OnDeadlockCycle::kIgnore) {
 1483|      0|    return DeadlockCheck(mu);
 1484|      4|  } else {
 1485|      4|    return InvalidGraphId();
 1486|      4|  }
 1487|      4|}
mutex.cc:_ZN4absl12lts_20260817L18DebugOnlyLockEnterEPNS0_5MutexENS0_24synchronization_internal7GraphIdE:
 1313|      4|static inline void DebugOnlyLockEnter(Mutex* mu, GraphId id) {
 1314|      4|  if (kDebugMode) {
  ------------------
  |  Branch (1314:7): [Folded, False: 4]
  ------------------
 1315|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1315:9): [True: 0, False: 0]
  ------------------
 1316|      0|        OnDeadlockCycle::kIgnore) {
 1317|      0|      LockEnter(mu, id, Synch_GetAllLocks());
 1318|      0|    }
 1319|      0|  }
 1320|      4|}
mutex.cc:_ZN4absl12lts_20260817L18DebugOnlyLockLeaveEPNS0_5MutexE:
 1323|      4|static inline void DebugOnlyLockLeave(Mutex* mu) {
 1324|      4|  if (kDebugMode) {
  ------------------
  |  Branch (1324:7): [Folded, False: 4]
  ------------------
 1325|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1325:9): [True: 0, False: 0]
  ------------------
 1326|      0|        OnDeadlockCycle::kIgnore) {
 1327|      0|      LockLeave(mu, GetGraphId(mu), Synch_GetAllLocks());
 1328|      0|    }
 1329|      0|  }
 1330|      4|}

_ZN4absl12lts_202608175Mutex4LockEv:
  195|      4|  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { lock(); }
_ZN4absl12lts_202608175Mutex6UnlockEv:
  204|      4|  inline void Unlock() ABSL_UNLOCK_FUNCTION() { unlock(); }

_ZNK4absl12lts_202608174SpanIKNS0_19str_format_internal13FormatArgImplEE4sizeEv:
  321|    512|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202608174SpanIKNS0_19str_format_internal13FormatArgImplEEixEm:
  336|    256|  constexpr reference operator[](size_type i) const noexcept {
  337|    256|    absl::base_internal::HardeningAssertLT(i, size());
  338|    256|    return ptr_[i];
  339|    256|  }

_ZNK6google8protobuf8internal10LazyString4InitEv:
   58|      4|const std::string& LazyString::Init() const {
   59|      4|  static absl::Mutex mu{absl::kConstInit};
   60|      4|  mu.Lock();
   61|      4|  const std::string* res = inited_.load(std::memory_order_acquire);
   62|      4|  if (res == nullptr) {
  ------------------
  |  Branch (62:7): [True: 4, False: 0]
  ------------------
   63|      4|    auto init_value = init_value_;
   64|      4|    res = ::new (static_cast<void*>(string_buf_))
   65|      4|        std::string(init_value.ptr, init_value.size);
   66|      4|    inited_.store(res, std::memory_order_release);
   67|      4|  }
   68|      4|  mu.Unlock();
   69|      4|  return *res;
   70|      4|}
_ZN6google8protobuf8internal14ArenaStringPtr13MutableNoCopyEPNS0_5ArenaE:
  188|    298|std::string* ArenaStringPtr::MutableNoCopy(Arena* arena) {
  189|    298|  ScopedCheckPtrInvariants check(&tagged_ptr_);
  190|    298|  if (tagged_ptr_.IsMutable()) {
  ------------------
  |  Branch (190:7): [True: 0, False: 298]
  ------------------
  191|      0|    return tagged_ptr_.Get();
  192|    298|  } else {
  193|    298|    ABSL_DCHECK(IsDefault());
  ------------------
  |  |   47|    298|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|    298|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|    596|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|    298|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|    596|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|    596|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 298, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|    298|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 298]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|    298|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 298, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|    596|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|    596|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  194|       |    // Allocate empty. The contents are not relevant.
  195|    298|    return NewString(arena);
  196|    298|  }
  197|    298|}
_ZN6google8protobuf8internal24ScopedCheckPtrInvariantsC2EPKNS1_15TaggedStringPtrE:
   97|    298|  explicit ScopedCheckPtrInvariants(const TaggedStringPtr*) {}

_ZNK6google8protobuf8internal14ArenaStringPtr3GetEv:
  338|  1.44k|  PROTOBUF_NDEBUG_INLINE const std::string& Get() const {
  339|       |    // Unconditionally mask away the tag.
  340|  1.44k|    return *tagged_ptr_.Get();
  341|  1.44k|  }
_ZNK6google8protobuf8internal15TaggedStringPtr3GetEv:
  164|  1.44k|  inline std::string* Get() const {
  165|  1.44k|    return reinterpret_cast<std::string*>(as_int() & ~kMask);
  166|  1.44k|  }
_ZNK6google8protobuf8internal15TaggedStringPtr6as_intEv:
  200|  1.75k|  uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
_ZNK6google8protobuf8internal14ArenaStringPtr9IsDefaultEv:
  395|      8|  inline bool IsDefault() const { return tagged_ptr_.IsDefault(); }
_ZNK6google8protobuf8internal15TaggedStringPtr9IsDefaultEv:
  141|      8|  inline bool IsDefault() const { return (as_int() & kMask) == kDefault; }
_ZNK6google8protobuf8internal10LazyString3getEv:
   59|      8|  const std::string& get() const {
   60|       |    // This check generates less code than a call-once invocation.
   61|      8|    auto* res = inited_.load(std::memory_order_acquire);
   62|      8|    if (ABSL_PREDICT_FALSE(res == nullptr)) return Init();
  ------------------
  |  |  190|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 4, False: 4]
  |  |  |  Branch (190:49): [Folded, False: 8]
  |  |  |  Branch (190:58): [True: 4, False: 4]
  |  |  ------------------
  ------------------
   63|      4|    return *res;
   64|      8|  }
_ZN6google8protobuf8internal15TaggedStringPtr12SetAllocatedEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  119|    298|  inline std::string* SetAllocated(std::string* p) {
  120|    298|    return TagAs(kAllocated, p);
  121|    298|  }
_ZNK6google8protobuf8internal15TaggedStringPtr9IsMutableEv:
  138|    298|  inline bool IsMutable() const { return as_int() & kMutableBit; }
_ZN6google8protobuf8internal15TaggedStringPtr14assert_alignedEPKv:
  183|    298|  static inline void assert_aligned(const void* p) {
  184|    298|    static_assert(kMask <= alignof(void*), "Pointer underaligned for bit mask");
  185|    298|    static_assert(kMask <= alignof(std::string),
  186|    298|                  "std::string underaligned for bit mask");
  187|    298|    ABSL_DCHECK_EQ(reinterpret_cast<uintptr_t>(p) & kMask, 0UL);
  ------------------
  |  |   74|    298|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|    298|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    298|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 298]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    298|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  188|    298|  }
_ZN6google8protobuf8internal15TaggedStringPtr5TagAsENS2_4TypeEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
  193|    298|  inline std::string* TagAs(Type type, std::string* p) {
  194|    298|    ABSL_DCHECK(p != nullptr);
  ------------------
  |  |   47|    298|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|    298|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|    596|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|    298|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|    596|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|    596|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 298, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|    298|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 298]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|    298|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 298, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|    596|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|    596|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  195|    298|    assert_aligned(p);
  196|    298|    ptr_ = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(p) | type);
  197|    298|    return p;
  198|    298|  }
_ZN6google8protobuf8internal14ArenaStringPtr9NewStringIJEEEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaEDpOT_:
  399|    298|  inline std::string* NewString(Arena* arena, Args&&... args) {
  400|    298|    if (arena == nullptr) {
  ------------------
  |  Branch (400:9): [True: 298, False: 0]
  ------------------
  401|    298|      auto* s = new std::string(std::forward<Args>(args)...);
  402|    298|      return tagged_ptr_.SetAllocated(s);
  403|    298|    } else {
  404|      0|      auto* s = Arena::Create<std::string>(arena, std::forward<Args>(args)...);
  405|      0|      return tagged_ptr_.SetMutableArena(s);
  406|      0|    }
  407|    298|  }

_ZNK6google8protobuf8internal14MessageCreator3tagEv:
   98|    300|  Tag tag() const { return tag_; }
_ZNK6google8protobuf8internal9ClassData16default_instanceEv:
  203|    598|  const MessageLite* default_instance() const { return prototype; }
_ZNK6google8protobuf8internal13ClassDataLite4baseEv:
  227|    300|  constexpr const ClassData* base() const { return this; }
_ZNK6google8protobuf8internal14MessageCreator15AllocateMessageINS0_5ArenaEEEPvPT_:
   90|    300|  void* AllocateMessage(Arena* arena) const {
   91|    300|    if (arena != nullptr) {
  ------------------
  |  Branch (91:9): [True: 0, False: 300]
  ------------------
   92|      0|      return arena->AllocateAligned(allocation_size_);
   93|    300|    } else {
   94|    300|      return Allocate(allocation_size_);
   95|    300|    }
   96|    300|  }

_ZN6google8protobuf8internal13little_endian6ToHostEt:
  100|    864|inline uint16_t ToHost(uint16_t value) {
  101|       |#if defined(ABSL_IS_BIG_ENDIAN)
  102|       |  return BSwap16(value);
  103|       |#else
  104|    864|  return value;
  105|    864|#endif
  106|    864|}
_ZN6google8protobuf8internal13little_endian6ToHostEj:
  109|    298|inline uint32_t ToHost(uint32_t value) {
  110|       |#if defined(ABSL_IS_BIG_ENDIAN)
  111|       |  return BSwap32(value);
  112|       |#else
  113|    298|  return value;
  114|    298|#endif
  115|    298|}

_ZN6google8protobuf8internal12ExtensionSet5ClearEv:
  762|      1|void ExtensionSet::Clear() {
  763|      1|  ForEach([](int /* number */, Extension& ext) { ext.Clear(); }, Prefetch{});
  764|      1|}
_ZNK6google8protobuf8internal12ExtensionSet13IsInitializedEPNS0_5ArenaEPKNS0_11MessageLiteE:
 1111|    301|                                 const MessageLite* extendee) const {
 1112|       |  // Extensions are never required.  However, we need to check that all
 1113|       |  // embedded messages are initialized.
 1114|    301|  if (ABSL_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  190|    301|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 301]
  |  |  |  Branch (190:49): [Folded, False: 301]
  |  |  |  Branch (190:58): [True: 0, False: 301]
  |  |  ------------------
  ------------------
 1115|      0|    for (const auto& kv : *map_.large) {
  ------------------
  |  Branch (1115:25): [True: 0, False: 0]
  ------------------
 1116|      0|      if (!kv.second.IsInitialized(this, extendee, kv.first, arena)) {
  ------------------
  |  Branch (1116:11): [True: 0, False: 0]
  ------------------
 1117|      0|        return false;
 1118|      0|      }
 1119|      0|    }
 1120|      0|    return true;
 1121|      0|  }
 1122|    301|  for (const KeyValue* it = flat_begin(); it != flat_end(); ++it) {
  ------------------
  |  Branch (1122:43): [True: 0, False: 301]
  ------------------
 1123|      0|    if (!it->second.IsInitialized(this, extendee, it->first, arena)) {
  ------------------
  |  Branch (1123:9): [True: 0, False: 0]
  ------------------
 1124|      0|      return false;
 1125|      0|    }
 1126|      0|  }
 1127|    301|  return true;
 1128|    301|}

_ZNK6google8protobuf8internal12ExtensionSet8is_largeEv:
  914|    302|  bool is_large() const { return static_cast<int16_t>(flat_size_) < 0; }
_ZN6google8protobuf8internal12ExtensionSet10flat_beginEv:
 1210|      1|  KeyValue* flat_begin() {
 1211|       |    assert(!is_large());
 1212|      1|    return map_.flat;
 1213|      1|  }
_ZNK6google8protobuf8internal12ExtensionSet10flat_beginEv:
 1214|    301|  const KeyValue* flat_begin() const {
 1215|       |    assert(!is_large());
 1216|    301|    return map_.flat;
 1217|    301|  }
_ZN6google8protobuf8internal12ExtensionSet8flat_endEv:
 1218|      1|  KeyValue* flat_end() {
 1219|       |    assert(!is_large());
 1220|      1|    return map_.flat + flat_size_;
 1221|      1|  }
_ZNK6google8protobuf8internal12ExtensionSet8flat_endEv:
 1222|    301|  const KeyValue* flat_end() const {
 1223|       |    assert(!is_large());
 1224|    301|    return map_.flat + flat_size_;
 1225|    301|  }
_ZN6google8protobuf8internal12ExtensionSetC2Ev:
  265|      1|  constexpr ExtensionSet() = default;
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIZNS2_5ClearEvE3$_0NS2_8PrefetchEEEvT_T0_:
  964|      1|  void ForEach(KeyValueFunctor func, PrefetchFunctor prefetch_func) {
  965|      1|    if (ABSL_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  966|      0|      ForEachPrefetchImpl(map_.large->begin(), map_.large->end(),
  967|      0|                          std::move(func), std::move(prefetch_func));
  968|      0|      return;
  969|      0|    }
  970|      1|    ForEachPrefetchImpl(flat_begin(), flat_end(), std::move(func),
  971|      1|                        std::move(prefetch_func));
  972|      1|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet19ForEachPrefetchImplIPNS2_8KeyValueEZNS2_5ClearEvE3$_0NS2_8PrefetchEEEvT_S8_T0_T1_:
  939|      1|                                  PrefetchFunctor prefetch_func) {
  940|       |    // Note: based on arena's ChunkList::Cleanup().
  941|       |    // Prefetch distance 16 performs better than 8 in load tests.
  942|      1|    constexpr int kPrefetchDistance = 16;
  943|      1|    Iterator prefetch = it;
  944|       |    // Prefetch the first kPrefetchDistance extensions.
  945|      1|    for (int i = 0; prefetch != end && i < kPrefetchDistance; ++prefetch, ++i) {
  ------------------
  |  Branch (945:21): [True: 0, False: 1]
  |  Branch (945:40): [True: 0, False: 0]
  ------------------
  946|      0|      prefetch_func(prefetch->second.PrefetchPtr());
  947|      0|    }
  948|       |    // For the middle extensions, call func and then prefetch the extension
  949|       |    // kPrefetchDistance after the current one.
  950|      1|    for (; prefetch != end; ++it, ++prefetch) {
  ------------------
  |  Branch (950:12): [True: 0, False: 1]
  ------------------
  951|      0|      func(it->first, it->second);
  952|      0|      prefetch_func(prefetch->second.PrefetchPtr());
  953|      0|    }
  954|       |    // Call func on the rest without prefetching.
  955|      1|    for (; it != end; ++it) func(it->first, it->second);
  ------------------
  |  Branch (955:12): [True: 0, False: 1]
  ------------------
  956|      1|  }

_ZN6google8protobuf8internal11TcFieldDataC2ENS2_11DefaultInitE:
   64|  2.02k|  TcFieldData(DefaultInit) {}  // NOLINT(google-explicit-constructor)
_ZNK6google8protobuf8internal11TcFieldData10hasbit_idxEv:
   85|    863|  uint8_t hasbit_idx() const { return static_cast<uint8_t>(data >> 16); }
_ZNK6google8protobuf8internal11TcFieldData7aux_idxEv:
   86|    263|  uint8_t aux_idx() const { return static_cast<uint8_t>(data >> 24); }
_ZNK6google8protobuf8internal11TcFieldData6offsetEv:
   87|    863|  uint16_t offset() const { return static_cast<uint16_t>(data >> 48); }
_ZNK6google8protobuf8internal11TcFieldData3tagEv:
  145|      1|  uint32_t tag() const { return static_cast<uint32_t>(data); }
_ZNK6google8protobuf8internal11TcFieldData12entry_offsetEv:
  146|      1|  uint32_t entry_offset() const { return static_cast<uint32_t>(data >> 32); }
_ZNK6google8protobuf8internal16TcParseTableBase14FastFieldEntry6targetEv:
  376|    864|    TailCallParseFunc target() const { return target_function; }
_ZNK6google8protobuf8internal16TcParseTableBase10fast_entryEm:
  379|    864|  const FastFieldEntry* fast_entry(size_t idx) const {
  380|    864|    return reinterpret_cast<const FastFieldEntry*>(this + 1) + idx;
  381|    864|  }
_ZNK6google8protobuf8internal16TcParseTableBase18field_lookup_beginEv:
  421|      1|  const uint16_t* field_lookup_begin() const {
  422|      1|    return reinterpret_cast<const uint16_t*>(reinterpret_cast<uintptr_t>(this) +
  423|      1|                                             lookup_table_offset);
  424|      1|  }
_ZNK6google8protobuf8internal16TcParseTableBase19field_entries_beginEv:
  441|      1|  const FieldEntry* field_entries_begin() const {
  442|      1|    return reinterpret_cast<const FieldEntry*>(
  443|      1|        reinterpret_cast<uintptr_t>(this) + field_entries_offset);
  444|      1|  }
_ZNK6google8protobuf8internal16TcParseTableBase8FieldAux9table_ptrEv:
  492|      3|    const TcParseTableBase* table_ptr() const {
  493|      3|#ifndef PROTOBUF_MESSAGE_GLOBALS
  494|      3|      return table;
  495|       |#else
  496|       |      return MessageGlobalsBase::ToParseTableBase(message_globals_p);
  497|       |#endif
  498|      3|    }
_ZNK6google8protobuf8internal16TcParseTableBase9field_auxEj:
  500|      3|  const FieldAux* field_aux(uint32_t idx) const {
  501|      3|    return reinterpret_cast<const FieldAux*>(reinterpret_cast<uintptr_t>(this) +
  502|      3|                                             aux_offset) +
  503|      3|           idx;
  504|      3|  }
_ZNK6google8protobuf8internal11TcFieldData9coded_tagIhEET_v:
   82|    860|  TagType coded_tag() const {
   83|    860|    return static_cast<TagType>(data);
   84|    860|  }
_ZNK6google8protobuf8internal11TcFieldData9coded_tagItEET_v:
   82|      4|  TagType coded_tag() const {
   83|      4|    return static_cast<TagType>(data);
   84|      4|  }

_ZN6google8protobuf8internal8TcParser11SyncHasbitsEPNS0_11MessageLiteEmPKNS1_16TcParseTableBaseE:
  924|    302|      MessageLite* msg, uint64_t hasbits, const TcParseTableBase* table) {
  925|    302|    const uint32_t has_bits_offset = table->has_bits_offset;
  926|       |    if constexpr (internal::PerformDebugChecks()) {
  927|       |      // We always have some offset to write to.
  928|       |      ABSL_DCHECK_NE(has_bits_offset, 0u);
  929|       |      // and if we actually have has bits to push, we should be pushing to a
  930|       |      // real HasBits.
  931|       |      // `has_bits_offset` points to `_cached_size_` when we have
  932|       |      // no has bits, just to point somewhere and avoid a branch here.
  933|       |      // In that case we would be doing `|= 0` so the target just need to be
  934|       |      // some valid space in the message.
  935|       |      if (static_cast<uint32_t>(hasbits) != 0) {
  936|       |        ABSL_DCHECK_NE(has_bits_offset, table->class_data->cached_size_offset);
  937|       |      }
  938|       |    }
  939|       |    // Only the first 32 has-bits are updated. Nothing above those is stored,
  940|       |    // but e.g. messages without has-bits update the upper bits.
  941|    302|    RefAt<uint32_t>(msg, has_bits_offset) |= static_cast<uint32_t>(hasbits);
  942|    302|  }
_ZN6google8protobuf8internal8TcParser11TagDispatchEPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1142|    864|    PROTOBUF_TC_PARAM_NO_DATA_DECL) {
 1143|    864|  const auto coded_tag = UnalignedLoad<uint16_t>(ptr);
 1144|    864|  const size_t idx = coded_tag & table->fast_idx_mask;
 1145|    864|  PROTOBUF_ASSUME((idx & 7) == 0);
  ------------------
  |  |  733|    864|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
 1146|    864|  auto* fast_entry = table->fast_entry(idx >> 3);
 1147|    864|  TcFieldData data = fast_entry->bits;
 1148|    864|  data.data ^= coded_tag;
 1149|    864|  PROTOBUF_MUSTTAIL return fast_entry->target()(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  233|    864|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return fast_entry->target()(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|    864|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1150|    864|}
_ZN6google8protobuf8internal8TcParser13ToTagDispatchEPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1158|    862|    PROTOBUF_TC_PARAM_NO_DATA_DECL) {
 1159|    862|  constexpr bool always_return = !PROTOBUF_TAILCALL;
  ------------------
  |  |  234|    862|#define PROTOBUF_TAILCALL true
  ------------------
 1160|    862|  if (always_return || !ctx->DataAvailable(ptr)) {
  ------------------
  |  Branch (1160:7): [Folded, False: 862]
  |  Branch (1160:24): [True: 300, False: 562]
  ------------------
 1161|    300|    PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|    300|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|    300|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1162|    300|  }
 1163|    562|  PROTOBUF_MUSTTAIL return TagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|    562|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return TagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|    562|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1164|    862|}
_ZN6google8protobuf8internal8TcParser11ToParseLoopEPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1167|    300|    PROTOBUF_TC_PARAM_NO_DATA_DECL) {
 1168|    300|  (void)ctx;
 1169|    300|  SyncHasbits(msg, hasbits, table);
 1170|    300|  return ptr;
 1171|    300|}
_ZN6google8protobuf8internal8TcParser9ParseLoopEPNS0_11MessageLiteEPKcPNS1_12ParseContextEPKNS1_16TcParseTableBaseE:
 1175|    301|    const TcParseTableBase* table) {
 1176|       |  // Note: TagDispatch uses a dispatch table at "&table->fast_entries".
 1177|       |  // For fast dispatch, we'd like to have a pointer to that, but if we use
 1178|       |  // that expression, there's no easy way to get back to "table", which we also
 1179|       |  // need during dispatch.  It turns out that "table + 1" points exactly to
 1180|       |  // fast_entries, so we just increment table by 1 here, to get the register
 1181|       |  // holding the value we want.
 1182|    301|  table += 1;
 1183|    603|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (1183:10): [True: 302, False: 301]
  ------------------
 1184|    302|#if defined(__GNUC__)
 1185|       |    // Note: this asm prevents the compiler (clang, specifically) from
 1186|       |    // believing (thanks to CSE) that it needs to dedicate a register both
 1187|       |    // to "table" and "&table->fast_entries".
 1188|       |    // TODO: remove this asm
 1189|    302|    asm("" : "+r"(table));
 1190|    302|#endif
 1191|    302|    ptr = TagDispatch(msg, ptr, ctx, TcFieldData::DefaultInit(), table - 1, 0);
 1192|    302|    if (ptr == nullptr) break;
  ------------------
  |  Branch (1192:9): [True: 0, False: 302]
  ------------------
 1193|    302|    if (ctx->LastTag() != 1) break;  // Ended on terminating tag
  ------------------
  |  Branch (1193:9): [True: 0, False: 302]
  ------------------
 1194|    302|  }
 1195|    301|  table -= 1;
 1196|    301|  if (ABSL_PREDICT_FALSE(table->has_post_loop_handler)) {
  ------------------
  |  |  190|    301|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 301]
  |  |  |  Branch (190:49): [Folded, False: 301]
  |  |  |  Branch (190:58): [True: 0, False: 301]
  |  |  ------------------
  ------------------
 1197|      0|    return table->post_loop_handler(msg, ptr, ctx);
 1198|      0|  }
 1199|    301|  if (ABSL_PREDICT_FALSE(PerformDebugChecks() && ptr == nullptr)) {
  ------------------
  |  |  190|    301|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [Folded, False: 301]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:59): [Folded, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1200|      0|    CheckHasBitConsistency(msg, table);
 1201|      0|  }
 1202|    301|  return ptr;
 1203|    301|}
_ZN6google8protobuf8internal8TcParser5RefAtIjEERT_Pvm:
  727|    602|  static inline T& RefAt(void* x, size_t offset) {
  728|    602|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  729|       |#if !defined(NDEBUG) && !(defined(_MSC_VER) && defined(_M_IX86))
  730|       |    // Check the alignment in debug mode, except in 32-bit msvc because it does
  731|       |    // not respect the alignment as expressed by `alignof(T)`
  732|       |    if (ABSL_PREDICT_FALSE(reinterpret_cast<uintptr_t>(target) % alignof(T) !=
  733|       |                           0)) {
  734|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  735|       |                reinterpret_cast<uintptr_t>(target));
  736|       |    }
  737|       |#endif
  738|    602|    return *target;
  739|    602|  }
_ZN6google8protobuf8internal8TcParser5RefAtINS1_16TcParseTableBase10FieldEntryEEERKT_PKvm:
  742|      1|  static inline const T& RefAt(const void* x, size_t offset) {
  743|      1|    const T* target =
  744|      1|        reinterpret_cast<const T*>(static_cast<const char*>(x) + offset);
  745|       |#if !defined(NDEBUG) && !(defined(_MSC_VER) && defined(_M_IX86))
  746|       |    // Check the alignment in debug mode, except in 32-bit msvc because it does
  747|       |    // not respect the alignment as expressed by `alignof(T)`
  748|       |    if (ABSL_PREDICT_FALSE(reinterpret_cast<uintptr_t>(target) % alignof(T) !=
  749|       |                           0)) {
  750|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  751|       |                reinterpret_cast<uintptr_t>(target));
  752|       |    }
  753|       |#endif
  754|      1|    return *target;
  755|      1|  }
_ZN6google8protobuf8internal8TcParser5RefAtINS1_20RepeatedPtrFieldBaseEEERT_Pvm:
  727|      1|  static inline T& RefAt(void* x, size_t offset) {
  728|      1|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  729|       |#if !defined(NDEBUG) && !(defined(_MSC_VER) && defined(_M_IX86))
  730|       |    // Check the alignment in debug mode, except in 32-bit msvc because it does
  731|       |    // not respect the alignment as expressed by `alignof(T)`
  732|       |    if (ABSL_PREDICT_FALSE(reinterpret_cast<uintptr_t>(target) % alignof(T) !=
  733|       |                           0)) {
  734|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  735|       |                reinterpret_cast<uintptr_t>(target));
  736|       |    }
  737|       |#endif
  738|      1|    return *target;
  739|      1|  }
_ZN6google8protobuf8internal8TcParser5RefAtIbEERT_Pvm:
  727|      4|  static inline T& RefAt(void* x, size_t offset) {
  728|      4|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  729|       |#if !defined(NDEBUG) && !(defined(_MSC_VER) && defined(_M_IX86))
  730|       |    // Check the alignment in debug mode, except in 32-bit msvc because it does
  731|       |    // not respect the alignment as expressed by `alignof(T)`
  732|       |    if (ABSL_PREDICT_FALSE(reinterpret_cast<uintptr_t>(target) % alignof(T) !=
  733|       |                           0)) {
  734|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  735|       |                reinterpret_cast<uintptr_t>(target));
  736|       |    }
  737|       |#endif
  738|      4|    return *target;
  739|      4|  }
_ZN6google8protobuf8internal8TcParser5RefAtIiEERT_Pvm:
  727|    260|  static inline T& RefAt(void* x, size_t offset) {
  728|    260|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  729|       |#if !defined(NDEBUG) && !(defined(_MSC_VER) && defined(_M_IX86))
  730|       |    // Check the alignment in debug mode, except in 32-bit msvc because it does
  731|       |    // not respect the alignment as expressed by `alignof(T)`
  732|       |    if (ABSL_PREDICT_FALSE(reinterpret_cast<uintptr_t>(target) % alignof(T) !=
  733|       |                           0)) {
  734|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  735|       |                reinterpret_cast<uintptr_t>(target));
  736|       |    }
  737|       |#endif
  738|    260|    return *target;
  739|    260|  }
_ZN6google8protobuf8internal8TcParser5RefAtINS1_14ArenaStringPtrEEERT_Pvm:
  727|    298|  static inline T& RefAt(void* x, size_t offset) {
  728|    298|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  729|       |#if !defined(NDEBUG) && !(defined(_MSC_VER) && defined(_M_IX86))
  730|       |    // Check the alignment in debug mode, except in 32-bit msvc because it does
  731|       |    // not respect the alignment as expressed by `alignof(T)`
  732|       |    if (ABSL_PREDICT_FALSE(reinterpret_cast<uintptr_t>(target) % alignof(T) !=
  733|       |                           0)) {
  734|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  735|       |                reinterpret_cast<uintptr_t>(target));
  736|       |    }
  737|       |#endif
  738|    298|    return *target;
  739|    298|  }
_ZN6google8protobuf8internal8TcParser5RefAtIPNS0_11MessageLiteEEERT_Pvm:
  727|      2|  static inline T& RefAt(void* x, size_t offset) {
  728|      2|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  729|       |#if !defined(NDEBUG) && !(defined(_MSC_VER) && defined(_M_IX86))
  730|       |    // Check the alignment in debug mode, except in 32-bit msvc because it does
  731|       |    // not respect the alignment as expressed by `alignof(T)`
  732|       |    if (ABSL_PREDICT_FALSE(reinterpret_cast<uintptr_t>(target) % alignof(T) !=
  733|       |                           0)) {
  734|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  735|       |                reinterpret_cast<uintptr_t>(target));
  736|       |    }
  737|       |#endif
  738|      2|    return *target;
  739|      2|  }

_ZN6google8protobuf8internal8TcParser14FindFieldEntryEPKNS1_16TcParseTableBaseEj:
  357|      1|    const TcParseTableBase* table, uint32_t field_num) {
  358|      1|  const FieldEntry* const field_entries = table->field_entries_begin();
  359|       |
  360|      1|  uint32_t fstart = 1;
  361|      1|  uint32_t adj_fnum = field_num - fstart;
  362|       |
  363|      1|  if (ABSL_PREDICT_TRUE(adj_fnum < 32)) {
  ------------------
  |  |  191|      1|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 1]
  |  |  |  Branch (191:48): [Folded, False: 1]
  |  |  |  Branch (191:57): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  364|      0|    uint32_t skipmap = table->skipmap32;
  365|      0|    uint32_t skipbit = 1 << adj_fnum;
  366|      0|    if (ABSL_PREDICT_FALSE(skipmap & skipbit)) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  367|      0|    skipmap &= skipbit - 1;
  368|      0|    adj_fnum -= absl::popcount(skipmap);
  369|      0|    auto* entry = field_entries + adj_fnum;
  370|      0|    PROTOBUF_ASSUME(entry != nullptr);
  ------------------
  |  |  733|      0|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  371|      0|    return entry;
  372|      0|  }
  373|      1|  const uint16_t* lookup_table = table->field_lookup_begin();
  374|      1|  for (;;) {
  375|      1|#ifdef ABSL_IS_LITTLE_ENDIAN
  376|      1|    memcpy(&fstart, lookup_table, sizeof(fstart));
  377|       |#else
  378|       |    fstart = lookup_table[0] | (lookup_table[1] << 16);
  379|       |#endif
  380|      1|    lookup_table += sizeof(fstart) / sizeof(*lookup_table);
  381|      1|    uint32_t num_skip_entries = *lookup_table++;
  382|      1|    if (field_num < fstart) return nullptr;
  ------------------
  |  Branch (382:9): [True: 0, False: 1]
  ------------------
  383|      1|    adj_fnum = field_num - fstart;
  384|      1|    uint32_t skip_num = adj_fnum / 16;
  385|      1|    if (ABSL_PREDICT_TRUE(skip_num < num_skip_entries)) {
  ------------------
  |  |  191|      1|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 1]
  |  |  |  Branch (191:57): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  386|       |      // for each group of 16 fields we have:
  387|       |      // a bitmap of 16 bits
  388|       |      // a 16-bit field-entry offset for the first of them.
  389|      1|      auto* skip_data = lookup_table + (adj_fnum / 16) * (sizeof(SkipEntry16) /
  390|      1|                                                          sizeof(uint16_t));
  391|      1|      SkipEntry16 se = {skip_data[0], skip_data[1]};
  392|      1|      adj_fnum &= 15;
  393|      1|      uint32_t skipmap = se.skipmap;
  394|      1|      uint16_t skipbit = 1 << adj_fnum;
  395|      1|      if (ABSL_PREDICT_FALSE(skipmap & skipbit)) return nullptr;
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  396|      1|      skipmap &= skipbit - 1;
  397|      1|      adj_fnum += se.field_entry_offset;
  398|      1|      adj_fnum -= absl::popcount(skipmap);
  399|      1|      auto* entry = field_entries + adj_fnum;
  400|      1|      PROTOBUF_ASSUME(entry != nullptr);
  ------------------
  |  |  733|      1|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  401|      1|      return entry;
  402|      1|    }
  403|      0|    lookup_table +=
  404|      0|        num_skip_entries * (sizeof(SkipEntry16) / sizeof(*lookup_table));
  405|      0|  }
  406|      1|}
_ZN6google8protobuf8internal8TcParser9MiniParseEPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  592|      1|    PROTOBUF_TC_PARAM_NO_DATA_DECL) {
  593|      1|  PROTOBUF_MUSTTAIL return MiniParse<false>(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      1|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return MiniParse<false>(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      1|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  594|      1|}
_ZN6google8protobuf8internal8TcParser10AddMessageEPKNS1_9ClassDataERNS1_20RepeatedPtrFieldBaseEPNS0_5ArenaE:
  634|    298|                                  RepeatedPtrFieldBase& field, Arena* arena) {
  635|    298|  return field.AddFromPrototype<GenericTypeHandler<MessageLite>>(
  636|    298|      arena, class_data->default_instance());
  637|    298|}
_ZN6google8protobuf8internal8TcParser8FastMtS1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  738|      2|PROTOBUF_NOINLINE const char* TcParser::FastMtS1(PROTOBUF_TC_PARAM_DECL) {
  739|      2|  PROTOBUF_MUSTTAIL return SingularParseMessageAuxImpl<uint8_t, false, true>(
  ------------------
  |  |  233|      2|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
  740|      2|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|      2|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  741|      2|}
_ZN6google8protobuf8internal8TcParser8FastMtR1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  829|      1|PROTOBUF_NOINLINE const char* TcParser::FastMtR1(PROTOBUF_TC_PARAM_DECL) {
  830|      1|  PROTOBUF_MUSTTAIL return RepeatedParseMessageAuxImpl<uint8_t, false, true>(
  ------------------
  |  |  233|      1|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
  831|      1|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|      1|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  832|      1|}
_ZN6google8protobuf8internal8TcParser9FastF32S1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  866|    298|PROTOBUF_NOINLINE const char* TcParser::FastF32S1(PROTOBUF_TC_PARAM_DECL) {
  867|    298|  PROTOBUF_MUSTTAIL return SingularFixed<uint32_t, uint8_t>(
  ------------------
  |  |  233|    298|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
  868|    298|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|    298|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  869|    298|}
_ZN6google8protobuf8internal8TcParser8FastV8S1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1131|      3|PROTOBUF_NOINLINE const char* TcParser::FastV8S1(PROTOBUF_TC_PARAM_DECL) {
 1132|      3|  using TagType = uint8_t;
 1133|       |
 1134|       |  // Special case for a varint bool field with a tag of 1 byte:
 1135|       |  // The coded_tag() field will actually contain the value too and we can check
 1136|       |  // both at the same time.
 1137|      3|  auto coded_tag = data.coded_tag<uint16_t>();
 1138|      3|  if (ABSL_PREDICT_TRUE(coded_tag == 0x0000 || coded_tag == 0x0100)) {
  ------------------
  |  |  191|      6|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 3, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 3]
  |  |  |  Branch (191:58): [True: 0, False: 3]
  |  |  |  Branch (191:58): [True: 3, False: 0]
  |  |  ------------------
  ------------------
 1139|      3|    auto& field = RefAt<bool>(msg, data.offset());
 1140|       |    // Note: we use `data.data` because Clang generates suboptimal code when
 1141|       |    // using coded_tag.
 1142|       |    // In x86_64 this uses the CH register to read the second byte out of
 1143|       |    // `data`.
 1144|      3|    uint8_t value = data.data >> 8;
 1145|       |    // The assume allows using a mov instead of test+setne.
 1146|      3|    PROTOBUF_ASSUME(value <= 1);
  ------------------
  |  |  733|      3|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
 1147|      3|    field = static_cast<bool>(value);
 1148|       |
 1149|      3|    ptr += sizeof(TagType) + 1;  // Consume the tag and the value.
 1150|      3|    SetCachedHasBit(hasbits, data.hasbit_idx());
 1151|       |
 1152|      3|    PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      3|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      3|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1153|      3|  }
 1154|       |
 1155|       |  // If it didn't match above either the tag is wrong, or the value is encoded
 1156|       |  // non-canonically.
 1157|       |  // Jump to MiniParse as wrong tag is the most probable reason.
 1158|      0|  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1159|      3|}
_ZN6google8protobuf8internal8TcParser8FastV8S2EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1161|      1|PROTOBUF_NOINLINE const char* TcParser::FastV8S2(PROTOBUF_TC_PARAM_DECL) {
 1162|      1|  PROTOBUF_MUSTTAIL return SingularVarint<bool, uint16_t>(
  ------------------
  |  |  233|      1|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
 1163|      1|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|      1|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1164|      1|}
_ZN6google8protobuf8internal8TcParser9FastV32S1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1165|      1|PROTOBUF_NOINLINE const char* TcParser::FastV32S1(PROTOBUF_TC_PARAM_DECL) {
 1166|      1|  PROTOBUF_MUSTTAIL return FastVarintS1<uint32_t>(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  233|      1|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return FastVarintS1<uint32_t>(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|      1|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1167|      1|}
_ZN6google8protobuf8internal8TcParser9FastEr1S1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1610|    260|PROTOBUF_NOINLINE const char* TcParser::FastEr1S1(PROTOBUF_TC_PARAM_DECL) {
 1611|    260|  PROTOBUF_MUSTTAIL return SingularEnumSmallRange<uint8_t, 1>(
  ------------------
  |  |  233|    260|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
 1612|    260|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|    260|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1613|    260|}
_ZN6google8protobuf8internal8TcParser7FastBS1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1849|    298|PROTOBUF_NOINLINE const char* TcParser::FastBS1(PROTOBUF_TC_PARAM_DECL) {
 1850|    298|  PROTOBUF_MUSTTAIL return SingularString<uint8_t, ArenaStringPtr, kNoUtf8>(
  ------------------
  |  |  233|    298|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
 1851|    298|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|    298|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1852|    298|}
_ZN6google8protobuf8internal8TcParser17MaybeGetSplitBaseEPNS0_11MessageLiteEbPKNS1_16TcParseTableBaseE:
 2141|      1|                                  const TcParseTableBase* table) {
 2142|      1|  void* out = msg;
 2143|      1|  if (is_split) {
  ------------------
  |  Branch (2143:7): [True: 0, False: 1]
  ------------------
 2144|      0|    const uint32_t split_offset = GetSplitOffset(table);
 2145|      0|    void* default_split =
 2146|      0|        TcParser::RefAt<void*>(table->default_instance(), split_offset);
 2147|      0|    void*& split = TcParser::RefAt<void*>(msg, split_offset);
 2148|      0|    if (split == default_split) {
  ------------------
  |  Branch (2148:9): [True: 0, False: 0]
  ------------------
 2149|       |      // Allocate split instance when needed.
 2150|      0|      uint32_t size = GetSizeofSplit(table);
 2151|      0|      Arena* arena = msg->GetArena();
 2152|      0|      split =
 2153|      0|          (arena == nullptr) ? Allocate(size) : arena->AllocateAligned(size);
  ------------------
  |  Branch (2153:11): [True: 0, False: 0]
  ------------------
 2154|      0|      memcpy(split, default_split, size);
 2155|      0|    }
 2156|      0|    out = split;
 2157|      0|  }
 2158|      1|  return out;
 2159|      1|}
generated_message_tctable_lite.cc:_ZN6google8protobuf8internal12_GLOBAL__N_115SetCachedHasBitERmh:
   89|    863|                                            uint8_t hasbit_idx) {
   90|    863|  cached_hasbits |= uint64_t{1} << hasbit_idx;
   91|    863|}
_ZN6google8protobuf8internal8TcParser10NewMessageEPKNS1_9ClassDataEPNS0_5ArenaE:
  629|      2|    const ClassData* class_data, Arena* arena) {
  630|      2|  return class_data->New(arena);
  631|      2|}
_ZN6google8protobuf8internal8TcParser8MpVarintILb0EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 2300|      1|PROTOBUF_NOINLINE const char* TcParser::MpVarint(PROTOBUF_TC_PARAM_DECL) {
 2301|      1|  const auto& entry = RefAt<FieldEntry>(table, data.entry_offset());
 2302|      1|  const uint16_t type_card = entry.type_card;
 2303|      1|  const uint16_t card = type_card & field_layout::kFcMask;
 2304|       |
 2305|       |  // Check for repeated parsing:
 2306|      1|  if (card == field_layout::kFcRepeated) {
  ------------------
  |  Branch (2306:7): [True: 0, False: 1]
  ------------------
 2307|      0|    PROTOBUF_MUSTTAIL return MpRepeatedVarint<is_split>(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MpRepeatedVarint<is_split>(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 2308|      0|  }
 2309|       |  // Check for wire type mismatch:
 2310|      1|  if ((data.tag() & 7) != WireFormatLite::WIRETYPE_VARINT) {
  ------------------
  |  Branch (2310:7): [True: 0, False: 1]
  ------------------
 2311|      0|    PROTOBUF_MUSTTAIL return table->fallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return table->fallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 2312|      0|  }
 2313|      1|  const uint16_t xform_val = type_card & field_layout::kTvMask;
 2314|      1|  const bool is_zigzag = xform_val == field_layout::kTvZigZag;
 2315|      1|  const bool is_validated_enum = xform_val & field_layout::kTvEnum;
 2316|       |
 2317|       |  // Parse the value:
 2318|      1|  const char* ptr2 = ptr;  // save for unknown enum case
 2319|      1|  uint64_t tmp;
 2320|      1|  ptr = ParseVarint(ptr, &tmp);
 2321|      1|  if (ptr == nullptr) {
  ------------------
  |  Branch (2321:7): [True: 0, False: 1]
  ------------------
 2322|      0|    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 2323|      0|  }
 2324|       |
 2325|       |  // Transform and/or validate the value
 2326|      1|  uint16_t rep = type_card & field_layout::kRepMask;
 2327|      1|  if (rep == field_layout::kRep64Bits) {
  ------------------
  |  Branch (2327:7): [True: 0, False: 1]
  ------------------
 2328|      0|    if (is_zigzag) {
  ------------------
  |  Branch (2328:9): [True: 0, False: 0]
  ------------------
 2329|      0|      tmp = WireFormatLite::ZigZagDecode64(tmp);
 2330|      0|    }
 2331|      1|  } else if (rep == field_layout::kRep32Bits) {
  ------------------
  |  Branch (2331:14): [True: 0, False: 1]
  ------------------
 2332|      0|    if (is_validated_enum) {
  ------------------
  |  Branch (2332:9): [True: 0, False: 0]
  ------------------
 2333|      0|      if (!EnumIsValidAux(tmp, xform_val, *table->field_aux(&entry))) {
  ------------------
  |  Branch (2333:11): [True: 0, False: 0]
  ------------------
 2334|      0|        ptr = ptr2;
 2335|      0|        PROTOBUF_MUSTTAIL return MpUnknownEnumFallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                      PROTOBUF_MUSTTAIL return MpUnknownEnumFallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 2336|      0|      }
 2337|      0|    } else if (is_zigzag) {
  ------------------
  |  Branch (2337:16): [True: 0, False: 0]
  ------------------
 2338|      0|      tmp = WireFormatLite::ZigZagDecode32(static_cast<uint32_t>(tmp));
 2339|      0|    }
 2340|      0|  }
 2341|       |
 2342|       |  // Mark the field as present:
 2343|      1|  const bool is_oneof = card == field_layout::kFcOneof;
 2344|      1|  if (card == field_layout::kFcOptional) {
  ------------------
  |  Branch (2344:7): [True: 1, False: 0]
  ------------------
 2345|      1|    SetHas(entry, msg);
 2346|      1|  } else if (is_oneof) {
  ------------------
  |  Branch (2346:14): [True: 0, False: 0]
  ------------------
 2347|      0|    ChangeOneof(table, /*class_data=*/nullptr, entry, data.tag() >> 3, ctx,
 2348|      0|                msg);
 2349|      0|  }
 2350|       |
 2351|      1|  void* const base = MaybeGetSplitBase(msg, is_split, table);
 2352|      1|  if (rep == field_layout::kRep64Bits) {
  ------------------
  |  Branch (2352:7): [True: 0, False: 1]
  ------------------
 2353|      0|    RefAt<uint64_t>(base, entry.offset) = tmp;
 2354|      1|  } else if (rep == field_layout::kRep32Bits) {
  ------------------
  |  Branch (2354:14): [True: 0, False: 1]
  ------------------
 2355|      0|    RefAt<uint32_t>(base, entry.offset) = static_cast<uint32_t>(tmp);
 2356|      1|  } else {
 2357|      1|    ABSL_DCHECK_EQ(rep, static_cast<uint16_t>(field_layout::kRep8Bits));
  ------------------
  |  |   74|      1|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|      1|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      1|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 1]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      1|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2358|      1|    RefAt<bool>(base, entry.offset) = static_cast<bool>(tmp);
 2359|      1|  }
 2360|       |
 2361|      1|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      1|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      1|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 2362|      1|}
generated_message_tctable_lite.cc:_ZN6google8protobuf8internal12_GLOBAL__N_16SetHasERKNS1_16TcParseTableBase10FieldEntryEPNS0_11MessageLiteE:
 2005|      1|inline void SetHas(const FieldEntry& entry, MessageLite* msg) {
 2006|      1|  auto has_idx = static_cast<uint32_t>(entry.has_idx);
 2007|      1|  auto& hasblock = TcParser::RefAt<uint32_t>(msg, has_idx / 32 * 4);
 2008|      1|  hasblock |= uint32_t{1} << (has_idx % 32);
 2009|      1|}
_ZN6google8protobuf8internal8TcParser27GetTableAndClassDataFromAuxILb1EEENS2_17TableAndClassDataENS1_16TcParseTableBase8FieldAuxE:
  641|      1|    TcParseTableBase::FieldAux aux) {
  642|      1|  if constexpr (kIsTable) {
  643|      1|#ifndef PROTOBUF_MESSAGE_GLOBALS
  644|      1|    const TcParseTableBase* inner_table = aux.table_ptr();
  645|      1|    return {inner_table, inner_table->class_data};
  646|       |#else
  647|       |    const auto* globals = aux.message_globals();
  648|       |    return {MessageGlobalsBase::ToParseTableBase(globals),
  649|       |            MessageGlobalsBase::GetClassData(globals)};
  650|       |#endif
  651|       |  } else {
  652|       |    const MessageLite* prototype = aux.message_default();
  653|       |    const TcParseTableBase* inner_table = prototype->GetTcParseTable();
  654|       |    return {inner_table, inner_table->class_data};
  655|       |  }
  656|      1|}
_ZN6google8protobuf8internal8TcParser9MiniParseILb0EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  520|      1|PROTOBUF_ALWAYS_INLINE const char* TcParser::MiniParse(PROTOBUF_TC_PARAM_DECL) {
  521|      1|  TestMiniParseResult* test_out;
  522|      1|  if (export_called_function) {
  ------------------
  |  Branch (522:7): [Folded, False: 1]
  ------------------
  523|      0|    test_out = reinterpret_cast<TestMiniParseResult*>(
  524|      0|        static_cast<uintptr_t>(data.data));
  525|      0|  }
  526|       |
  527|      1|  uint32_t tag;
  528|      1|  ptr = ReadTagInlined(ptr, &tag);
  529|      1|  if (ABSL_PREDICT_FALSE(ptr == nullptr)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  530|      0|    if (export_called_function) *test_out = {Error};
  ------------------
  |  Branch (530:9): [Folded, False: 0]
  ------------------
  531|      0|    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  532|      0|  }
  533|       |
  534|      1|  auto* entry = FindFieldEntry(table, tag >> 3);
  535|      1|  if (entry == nullptr) {
  ------------------
  |  Branch (535:7): [True: 0, False: 1]
  ------------------
  536|      0|    if (export_called_function) *test_out = {table->fallback, tag};
  ------------------
  |  Branch (536:9): [Folded, False: 0]
  ------------------
  537|      0|    data.data = tag;
  538|      0|    PROTOBUF_MUSTTAIL return table->fallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return table->fallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  539|      0|  }
  540|       |
  541|       |  // The handler may need the tag and the entry to resolve fallback logic. Both
  542|       |  // of these are 32 bits, so pack them into (the 64-bit) `data`. Since we can't
  543|       |  // pack the entry pointer itself, just pack its offset from `table`.
  544|      1|  uint64_t entry_offset = reinterpret_cast<const char*>(entry) -
  545|      1|                          reinterpret_cast<const char*>(table);
  546|      1|  data.data = entry_offset << 32 | tag;
  547|       |
  548|      1|  using field_layout::FieldKind;
  549|       |
  550|      1|  static_assert(
  551|      1|      absl::has_single_bit(size_t{kMiniParseTableTypeCardMask} + 1) &&
  552|      1|          kMiniParseTableTypeCardMask + 1 == kMiniParseTableSize,
  553|      1|      "kMiniParseTableTypeCardMask must be of the form 2^n - 1, as it is used "
  554|      1|      "to index the mini parse table");
  555|       |
  556|      1|  auto field_type = entry->type_card & kMiniParseTableTypeCardMask;
  557|       |  // Just to be sure we got the order right, above.
  558|      1|  static_assert(0 == FieldKind::kFkNone, "Invalid table order");
  559|      1|  static_assert(1 == FieldKind::kFkVarint, "Invalid table order");
  560|      1|  static_assert(2 == FieldKind::kFkPackedVarint, "Invalid table order");
  561|      1|  static_assert(3 == FieldKind::kFkFixed, "Invalid table order");
  562|      1|  static_assert(4 == FieldKind::kFkPackedFixed, "Invalid table order");
  563|      1|  static_assert(5 == FieldKind::kFkString, "Invalid table order");
  564|      1|  static_assert(6 == FieldKind::kFkMessage, "Invalid table order");
  565|      1|  static_assert(7 == FieldKind::kFkMap, "Invalid table order");
  566|       |
  567|      1|  static_assert(8 == (+field_layout::kSplitMask | FieldKind::kFkNone),
  568|      1|                "Invalid table order");
  569|      1|  static_assert(9 == (+field_layout::kSplitMask | FieldKind::kFkVarint),
  570|      1|                "Invalid table order");
  571|      1|  static_assert(10 == (+field_layout::kSplitMask | FieldKind::kFkPackedVarint),
  572|      1|                "Invalid table order");
  573|      1|  static_assert(11 == (+field_layout::kSplitMask | FieldKind::kFkFixed),
  574|      1|                "Invalid table order");
  575|      1|  static_assert(12 == (+field_layout::kSplitMask | FieldKind::kFkPackedFixed),
  576|      1|                "Invalid table order");
  577|      1|  static_assert(13 == (+field_layout::kSplitMask | FieldKind::kFkString),
  578|      1|                "Invalid table order");
  579|      1|  static_assert(14 == (+field_layout::kSplitMask | FieldKind::kFkMessage),
  580|      1|                "Invalid table order");
  581|      1|  static_assert(15 == (+field_layout::kSplitMask | FieldKind::kFkMap),
  582|      1|                "Invalid table order");
  583|       |
  584|      1|  ABSL_DCHECK_LT(field_type, kMiniParseTableSize);
  ------------------
  |  |   80|      1|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|      1|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      1|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 1]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      1|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  585|      1|  TailCallParseFunc parse_fn = kMiniParseTable[field_type];
  586|      1|  if (export_called_function) *test_out = {parse_fn, tag, entry};
  ------------------
  |  Branch (586:7): [Folded, False: 1]
  ------------------
  587|       |
  588|      1|  PROTOBUF_MUSTTAIL return parse_fn(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  233|      1|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return parse_fn(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|      1|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  589|      1|}
_ZN6google8protobuf8internal8TcParser27SingularParseMessageAuxImplIhLb0ELb1EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  676|      2|    PROTOBUF_TC_PARAM_DECL) {
  677|      2|  PROTOBUF_PREFETCH_WITH_OFFSET(ptr, 192);
  ------------------
  |  |  594|      2|  asm("prefetcht0 " #offset "(%0)" : : "r"(base));
  ------------------
  678|      2|  PROTOBUF_PREFETCH_WITH_OFFSET(ptr, 256);
  ------------------
  |  |  594|      2|  asm("prefetcht0 " #offset "(%0)" : : "r"(base));
  ------------------
  679|      2|  if (ABSL_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  680|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  681|      0|  }
  682|      2|  auto saved_tag = UnalignedLoad<TagType>(ptr);
  683|      2|  ptr += sizeof(TagType);
  684|      2|  SetCachedHasBit(hasbits, data.hasbit_idx());
  685|      2|  SyncHasbits(msg, hasbits, table);
  686|      2|  auto& field = RefAt<MessageLite*>(msg, data.offset());
  687|      2|  const auto aux = *table->field_aux(data.aux_idx());
  688|      2|#ifndef PROTOBUF_MESSAGE_GLOBALS
  689|      2|  const auto* inner_table =
  690|      2|      aux_is_table ? aux.table_ptr() : aux.message_default()->GetTcParseTable();
  ------------------
  |  Branch (690:7): [True: 2, Folded]
  ------------------
  691|      2|  if (field == nullptr) {
  ------------------
  |  Branch (691:7): [True: 2, False: 0]
  ------------------
  692|      2|    field = NewMessage(inner_table->class_data, msg->GetArena());
  693|      2|  }
  694|       |#else
  695|       |  const TcParseTableBase* inner_table;
  696|       |  if constexpr (aux_is_table) {
  697|       |    inner_table = MessageGlobalsBase::ToParseTableBase(aux.message_globals());
  698|       |    if (field == nullptr) {
  699|       |      field =
  700|       |          NewMessage(MessageGlobalsBase::GetClassData(aux.message_globals()),
  701|       |                     msg->GetArena());
  702|       |    }
  703|       |  } else {
  704|       |    inner_table = aux.message_default()->GetTcParseTable();
  705|       |    if (field == nullptr) {
  706|       |      field = NewMessage(inner_table->class_data, msg->GetArena());
  707|       |    }
  708|       |  }
  709|       |#endif  // PROTOBUF_MESSAGE_GLOBALS
  710|      2|  const auto inner_loop = [&](const char* ptr) {
  711|      2|    return ParseLoop(field, ptr, ctx, inner_table);
  712|      2|  };
  713|      2|  return group_coding
  ------------------
  |  Branch (713:10): [Folded, False: 2]
  ------------------
  714|      2|             ? ctx->ParseGroupInlined(ptr, FastDecodeTag(saved_tag), inner_loop)
  715|      2|             : ctx->ParseLengthDelimitedInlined(ptr, inner_loop);
  716|      2|}
_ZZN6google8protobuf8internal8TcParser27SingularParseMessageAuxImplIhLb0ELb1EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEmENKUlS5_E_clES5_:
  710|      2|  const auto inner_loop = [&](const char* ptr) {
  711|      2|    return ParseLoop(field, ptr, ctx, inner_table);
  712|      2|  };
_ZN6google8protobuf8internal8TcParser27RepeatedParseMessageAuxImplIhLb0ELb1EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  774|      1|    PROTOBUF_TC_PARAM_DECL) {
  775|      1|  if (ABSL_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  776|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  777|      0|  }
  778|      1|  PROTOBUF_PREFETCH_WITH_OFFSET(ptr, 256);
  ------------------
  |  |  594|      1|  asm("prefetcht0 " #offset "(%0)" : : "r"(base));
  ------------------
  779|      1|  SetCachedHasBit(hasbits, data.hasbit_idx());
  780|      1|  Arena* arena = msg->GetArena();
  781|      1|  const auto expected_tag = UnalignedLoad<TagType>(ptr);
  782|      1|  const auto aux = *table->field_aux(data.aux_idx());
  783|      1|  auto& field = RefAt<RepeatedPtrFieldBase>(msg, data.offset());
  784|      1|  ABSL_DCHECK_EQ(field.GetArena(), arena);
  ------------------
  |  |   74|      1|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|      1|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      1|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 1]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      1|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  785|       |  // Captured structured bindings are a C++20 feature.
  786|      1|  auto [inner_table_alias, class_data] =
  787|      1|      GetTableAndClassDataFromAux<aux_is_table>(aux);
  788|      1|  const TcParseTableBase* inner_table = inner_table_alias;
  789|    298|  do {
  790|    298|    ptr += sizeof(TagType);
  791|    298|    MessageLite* submsg = AddMessage(class_data, field, arena);
  792|    298|    const auto inner_loop = [&](const char* ptr) {
  793|    298|      return ParseLoop(submsg, ptr, ctx, inner_table);
  794|    298|    };
  795|    298|    ptr = group_coding ? ctx->ParseGroupInlined(
  ------------------
  |  Branch (795:11): [Folded, False: 298]
  ------------------
  796|      0|                             ptr, FastDecodeTag(expected_tag), inner_loop)
  797|    298|                       : ctx->ParseLengthDelimitedInlined(ptr, inner_loop);
  798|    298|    if (ABSL_PREDICT_FALSE(ptr == nullptr)) {
  ------------------
  |  |  190|    298|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 298]
  |  |  |  Branch (190:49): [Folded, False: 298]
  |  |  |  Branch (190:58): [True: 0, False: 298]
  |  |  ------------------
  ------------------
  799|      0|      PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  800|      0|    }
  801|    298|    if (ABSL_PREDICT_FALSE(!ctx->DataAvailable(ptr))) {
  ------------------
  |  |  190|    298|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 298]
  |  |  |  Branch (190:49): [Folded, False: 298]
  |  |  |  Branch (190:58): [True: 0, False: 298]
  |  |  ------------------
  ------------------
  802|      0|      PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                    PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  803|      0|    }
  804|    298|  } while (UnalignedLoad<TagType>(ptr) == expected_tag);
  ------------------
  |  Branch (804:12): [True: 297, False: 1]
  ------------------
  805|       |
  806|      1|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      1|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      1|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  807|      1|}
_ZZN6google8protobuf8internal8TcParser27RepeatedParseMessageAuxImplIhLb0ELb1EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEmENKUlS5_E_clES5_:
  792|    298|    const auto inner_loop = [&](const char* ptr) {
  793|    298|      return ParseLoop(submsg, ptr, ctx, inner_table);
  794|    298|    };
_ZN6google8protobuf8internal8TcParser13SingularFixedIjhEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  855|    298|    PROTOBUF_TC_PARAM_DECL) {
  856|    298|  if (ABSL_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  190|    298|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 298]
  |  |  |  Branch (190:49): [Folded, False: 298]
  |  |  |  Branch (190:58): [True: 0, False: 298]
  |  |  ------------------
  ------------------
  857|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  858|      0|  }
  859|    298|  ptr += sizeof(TagType);  // Consume tag
  860|    298|  SetCachedHasBit(hasbits, data.hasbit_idx());
  861|    298|  RefAt<LayoutType>(msg, data.offset()) = UnalignedLoad<LayoutType>(ptr);
  862|    298|  ptr += sizeof(LayoutType);
  863|    298|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|    298|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|    298|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  864|    298|}
_ZN6google8protobuf8internal8TcParser14SingularVarintIbtLb0EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1079|      1|    PROTOBUF_TC_PARAM_DECL) {
 1080|      1|  if (ABSL_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 1081|      1|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      1|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      1|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1082|      1|  }
 1083|      0|  ptr += sizeof(TagType);  // Consume tag
 1084|      0|  SetCachedHasBit(hasbits, data.hasbit_idx());
 1085|       |
 1086|       |  // clang isn't smart enough to be able to only conditionally save
 1087|       |  // registers to the stack, so we turn the integer-greater-than-128
 1088|       |  // case into a separate routine.
 1089|      0|  if (ABSL_PREDICT_FALSE(static_cast<int8_t>(*ptr) < 0)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1090|      0|    PROTOBUF_MUSTTAIL return SingularVarBigint<FieldType, TagType, zigzag>(
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
 1091|      0|        PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  536|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1092|      0|  }
 1093|       |
 1094|      0|  RefAt<FieldType>(msg, data.offset()) =
 1095|      0|      ZigZagDecodeHelper<FieldType, zigzag>(static_cast<uint8_t>(*ptr++));
 1096|      0|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1097|      0|}
_ZN6google8protobuf8internal8TcParser12FastVarintS1IjEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1116|      1|    PROTOBUF_TC_PARAM_DECL) {
 1117|      1|  using TagType = uint8_t;
 1118|      1|  if (ABSL_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1119|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1120|      0|  }
 1121|      1|  int64_t res;
 1122|      1|  ptr = ShiftMixParseVarint<FieldType>(ptr + sizeof(TagType), res);
 1123|      1|  if (ABSL_PREDICT_FALSE(ptr == nullptr)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1124|      0|    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1125|      0|  }
 1126|      1|  SetCachedHasBit(hasbits, data.hasbit_idx());
 1127|      1|  RefAt<FieldType>(msg, data.offset()) = res;
 1128|      1|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      1|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      1|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1129|      1|}
generated_message_tctable_lite.cc:_ZN6google8protobuf8internal12_GLOBAL__N_111ParseVarintImEEPKcS5_PT_:
  962|      1|PROTOBUF_ALWAYS_INLINE const char* ParseVarint(const char* p, Type* value) {
  963|      1|  static_assert(sizeof(Type) == 4 || sizeof(Type) == 8,
  964|      1|                "Only [u]int32_t and [u]int64_t please");
  965|       |#ifdef __aarch64__
  966|       |  // The VarintParse parser has a faster implementation on ARM.
  967|       |  std::conditional_t<sizeof(Type) == 4, uint32_t, uint64_t> tmp;
  968|       |  p = VarintParse(p, &tmp);
  969|       |  if (p != nullptr) {
  970|       |    *value = tmp;
  971|       |  }
  972|       |  return p;
  973|       |#endif
  974|      1|  int64_t res;
  975|      1|  p = ShiftMixParseVarint<Type>(p, res);
  976|      1|  *value = res;
  977|      1|  return p;
  978|      1|}
_ZN6google8protobuf8internal8TcParser22SingularEnumSmallRangeIhLh1EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1584|    260|    PROTOBUF_TC_PARAM_DECL) {
 1585|    260|  if (ABSL_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  190|    260|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 260]
  |  |  |  Branch (190:49): [Folded, False: 260]
  |  |  |  Branch (190:58): [True: 0, False: 260]
  |  |  ------------------
  ------------------
 1586|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1587|      0|  }
 1588|       |
 1589|    260|  uint8_t v = ptr[sizeof(TagType)];
 1590|    260|  if (ABSL_PREDICT_FALSE(min > v || v > data.aux_idx())) {
  ------------------
  |  |  190|    520|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 260]
  |  |  |  Branch (190:49): [Folded, False: 260]
  |  |  |  Branch (190:59): [True: 0, False: 260]
  |  |  |  Branch (190:59): [True: 0, False: 260]
  |  |  ------------------
  ------------------
 1591|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1592|      0|  }
 1593|       |
 1594|    260|  RefAt<int32_t>(msg, data.offset()) = v;
 1595|    260|  ptr += sizeof(TagType) + 1;
 1596|    260|  SetCachedHasBit(hasbits, data.hasbit_idx());
 1597|    260|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|    260|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|    260|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1598|    260|}
_ZN6google8protobuf8internal8TcParser14SingularStringIhNS1_14ArenaStringPtrELNS2_8Utf8TypeE0EEEPKcPNS0_11MessageLiteES7_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1817|    298|    PROTOBUF_TC_PARAM_DECL) {
 1818|    298|  if (ABSL_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  190|    298|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 298]
  |  |  |  Branch (190:49): [Folded, False: 298]
  |  |  |  Branch (190:58): [True: 0, False: 298]
  |  |  ------------------
  ------------------
 1819|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1820|      0|  }
 1821|    298|  auto saved_tag = UnalignedLoad<TagType>(ptr);
 1822|    298|  ptr += sizeof(TagType);
 1823|    298|  SetCachedHasBit(hasbits, data.hasbit_idx());
 1824|    298|  auto& field = RefAt<FieldType>(msg, data.offset());
 1825|    298|  auto arena = msg->GetArena();
 1826|    298|  if (arena) {
  ------------------
  |  Branch (1826:7): [True: 0, False: 298]
  ------------------
 1827|      0|    ptr = ReadStringIntoArena(ptr, ctx, data, field, arena);
 1828|    298|  } else {
 1829|    298|    ptr = ReadStringNoArena(ptr, ctx, data, field);
 1830|    298|  }
 1831|    298|  if (ABSL_PREDICT_FALSE(ptr == nullptr)) {
  ------------------
  |  |  190|    298|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 298]
  |  |  |  Branch (190:49): [Folded, False: 298]
  |  |  |  Branch (190:58): [True: 0, False: 298]
  |  |  ------------------
  ------------------
 1832|      0|    EnsureArenaStringIsNotDefault(msg, &field);
 1833|      0|    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1834|      0|  }
 1835|    298|  switch (utf8) {
  ------------------
  |  Branch (1835:11): [Folded, False: 0]
  ------------------
 1836|    298|    case kNoUtf8:
  ------------------
  |  Branch (1836:5): [True: 298, False: 0]
  ------------------
 1837|    298|      break;
 1838|      0|    case kUtf8:
  ------------------
  |  Branch (1838:5): [True: 0, False: 298]
  ------------------
 1839|      0|      if (ABSL_PREDICT_TRUE(IsValidUTF8(field))) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1840|      0|        break;
 1841|      0|      }
 1842|      0|      ReportFastUtf8Error(FastDecodeTag(saved_tag), table);
 1843|      0|      PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1844|    298|  }
 1845|       |
 1846|    298|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  233|    298|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  549|    298|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1847|    298|}
generated_message_tctable_lite.cc:_ZN6google8protobuf8internal12_GLOBAL__N_117ReadStringNoArenaEPKcPNS1_12ParseContextENS1_11TcFieldDataERNS1_14ArenaStringPtrE:
 1770|    298|                              ArenaStringPtr& field) {
 1771|    298|  int size = ReadSize(&ptr);
 1772|    298|  if (!ptr) return nullptr;
  ------------------
  |  Branch (1772:7): [True: 0, False: 298]
  ------------------
 1773|    298|  return ctx->ReadString(ptr, size, field.MutableNoCopy(nullptr));
 1774|    298|}

_ZN6google8protobuf8internal24InitProtobufDefaultsSlowEv:
  104|      1|void InitProtobufDefaultsSlow() {
  105|      1|  static bool is_inited = InitProtobufDefaultsImpl();
  106|      1|  (void)is_inited;
  107|      1|}
generated_message_util.cc:_ZN6google8protobuf8internalL24InitProtobufDefaultsImplEv:
   93|      1|static bool InitProtobufDefaultsImpl() {
   94|      1|  if (auto* to_destroy = fixed_address_empty_string.Init()) {
  ------------------
  |  Branch (94:13): [True: 0, False: 1]
  ------------------
   95|      0|    OnShutdownDestroyString(to_destroy);
   96|      0|  }
   97|      1|  InitWeakDefaults();
   98|       |
   99|       |
  100|      1|  init_protobuf_defaults_state.store(true, std::memory_order_release);
  101|      1|  return true;
  102|      1|}
generated_message_util.cc:_ZN6google8protobuf8internalL16InitWeakDefaultsEv:
   72|      1|static void InitWeakDefaults() {
   73|       |  // force link the dummy entry.
   74|      1|  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|      1|  const char* start = &__start_pb_defaults;
   79|      1|  const char* end = &__stop_pb_defaults;
   80|      2|  while (start != end) {
  ------------------
  |  Branch (80:10): [True: 1, False: 1]
  ------------------
   81|      1|    auto* tail = reinterpret_cast<const WeakDescriptorDefaultTail*>(end) - 1;
   82|      1|    end -= tail->size;
   83|      1|    const MessageGlobalsBase* instance =
   84|      1|        reinterpret_cast<const MessageGlobalsBase*>(end);
   85|      1|    *tail->target = instance;
   86|      1|  }
   87|      1|}

_ZN6google8protobuf8internal17AllAreInitializedIN13sentencepiece24ModelProto_SentencePieceEEEbRKNS0_16RepeatedPtrFieldIT_EE:
  111|      1|    const RepeatedPtrField<Msg>& t) {
  112|    299|  for (int i = t.size(); --i >= 0;) {
  ------------------
  |  Branch (112:26): [True: 298, False: 1]
  ------------------
  113|    298|    if (!t.Get(i).IsInitialized()) return false;
  ------------------
  |  Branch (113:9): [True: 0, False: 298]
  ------------------
  114|    298|  }
  115|      1|  return true;
  116|      1|}

_ZNK6google8protobuf8internal7HasBitsILi1EEixEi:
   50|      4|  operator[](int index) const {
   51|      4|    return has_bits_[index];
   52|      4|  }
_ZN6google8protobuf8internal7HasBitsILi1EEixEi:
   45|      1|  PROTOBUF_NDEBUG_INLINE uint32_t& operator[](int index) {
   46|      1|    return has_bits_[index];
   47|      1|  }
_ZN6google8protobuf8internal7HasBitsILi1EEC2Ev:
   35|      1|  PROTOBUF_NDEBUG_INLINE constexpr HasBits() : has_bits_{} {}
_ZN6google8protobuf8internal7HasBitsILi1EE5ClearEv:
   41|      1|  PROTOBUF_NDEBUG_INLINE void Clear() {
   42|      1|    memset(has_bits_, 0, sizeof(has_bits_));
   43|      1|  }

_ZNK6google8protobuf8internal22InternalMetadataOffset6OffsetEv:
  150|      1|  constexpr int32_t Offset() const { return offset_; }
_ZN6google8protobuf8internal22InternalMetadataOffsetC2Ei:
  155|      1|  explicit constexpr InternalMetadataOffset(int32_t offset) : offset_(offset) {}
_ZN6google8protobuf8internal30TaggedInternalMetadataResolverILj0EEC2ENS1_22InternalMetadataOffsetE:
  173|      1|      : offset_(static_cast<uint32_t>(offset.Offset())) {
  174|      1|    ABSL_DCHECK_EQ(offset_ & kTagMask, uint32_t{0});
  ------------------
  |  |   74|      1|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|      1|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      1|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 1]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      1|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  175|      1|  }
_ZN6google8protobuf8internal22InternalMetadataOffset5BuildIN13sentencepiece10ModelProtoELm40EEES2_v:
   38|      1|  static constexpr PROTOBUF_ALWAYS_INLINE InternalMetadataOffset Build() {
   39|      1|    static_assert(
   40|      1|        std::is_same_v<std::remove_const_t<decltype(T::_internal_metadata_)>,
   41|      1|                       InternalMetadata>,
   42|      1|        "Field `_internal_metadata_ is not of type `InternalMetadata`");
   43|       |
   44|      1|    constexpr int64_t kInternalMetadataOffset =
   45|      1|        static_cast<int64_t>(PROTOBUF_FIELD_OFFSET(T, _internal_metadata_));
  ------------------
  |  |  311|      1|  _Pragma("clang diagnostic push")                           \
  |  |  312|      1|  _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \
  |  |  313|      1|  __builtin_offsetof(TYPE, FIELD)                            \
  |  |  314|      1|  _Pragma("clang diagnostic pop")
  ------------------
   46|       |
   47|      1|    static_assert(
   48|      1|        kInternalMetadataOffset - static_cast<int64_t>(kFieldOffset) >=
   49|      1|            int64_t{INT32_MIN},
   50|      1|        "Offset from `_internal_metadata_` is underflowing an int32_t, "
   51|      1|        "likely meaning your message body is too large.");
   52|      1|    static_assert(
   53|      1|        kInternalMetadataOffset - static_cast<int64_t>(kFieldOffset) <=
   54|      1|            int64_t{INT32_MAX},
   55|      1|        "Offset from `_internal_metadata_` is overflowing an int32_t, "
   56|      1|        "likely meaning your message body is too large.");
   57|       |
   58|      1|    return InternalMetadataOffset(
   59|      1|        static_cast<int32_t>(kInternalMetadataOffset - kFieldOffset));
   60|      1|  }

_ZN6google8protobuf8internal18InternalVisibilityC2Ev:
   49|      1|inline constexpr InternalVisibility::InternalVisibility() = default;

_ZN6google8protobuf2io16CodedInputStream24GetDefaultRecursionLimitEv:
  399|      1|  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD static int GetDefaultRecursionLimit() {
  400|      1|    return default_recursion_limit_;
  401|      1|  }

_ZN6google8protobuf8internal13MergeFromImplILb0EEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_11MessageLiteEPKNS1_16TcParseTableBaseENS8_10ParseFlagsE:
  228|      1|                   MessageLite::ParseFlags parse_flags) {
  229|      1|  const char* ptr;
  230|      1|  internal::ParseContext ctx(io::CodedInputStream::GetDefaultRecursionLimit(),
  231|      1|                             aliasing, &ptr, input);
  232|      1|  ptr = internal::TcParser::ParseLoop(msg, ptr, &ctx, tc_table);
  233|       |  // ctx has an explicit limit set (length of string_view).
  234|      1|  if (ABSL_PREDICT_TRUE(ptr && ctx.EndedAtLimit())) {
  ------------------
  |  |  191|      2|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 1]
  |  |  |  Branch (191:58): [True: 1, False: 0]
  |  |  |  Branch (191:58): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  235|      1|    return CheckFieldPresenceImpl(ctx, *msg, parse_flags);
  236|      1|  }
  237|      0|  return false;
  238|      1|}
_ZNK6google8protobuf11MessageLite3NewEPNS0_5ArenaE:
   92|    298|MessageLite* MessageLite::New(Arena* arena) const {
   93|    298|  auto* data = GetClassData();
   94|    298|  void* mem = data->message_creator.AllocateMessage(arena);
   95|       |  // The `instance->New()` expression requires using the actual instance
   96|       |  // instead of the prototype for the inner function call.
   97|       |  // Certain custom instances have special per-instance state that needs to be
   98|       |  // copied.
   99|    298|  return data->message_creator.PlacementNew(this, data->default_instance(), mem,
  100|    298|                                            arena);
  101|    298|}
_ZNK6google8protobuf11MessageLite13IsInitializedEv:
  103|      1|bool MessageLite::IsInitialized() const {
  104|      1|  auto* data = GetClassData();
  105|      1|  return data->is_initialized != nullptr ? data->is_initialized(*this) : true;
  ------------------
  |  Branch (105:10): [True: 1, False: 0]
  ------------------
  106|      1|}
_ZN6google8protobuf11MessageLite14ParseFromArrayEPKvi:
  425|      1|bool MessageLite::ParseFromArray(const void* data, int size) {
  426|      1|  return ParseFrom<kParse>(as_string_view(data, size));
  427|      1|}
message_lite.cc:_ZN6google8protobuf12_GLOBAL__N_122CheckFieldPresenceImplERKNS0_8internal12ParseContextERKNS0_11MessageLiteENS6_10ParseFlagsE:
  182|      1|                                   MessageLite::ParseFlags parse_flags) {
  183|      1|  (void)ctx;  // Parameter is used by Google-internal code.
  184|      1|  if (ABSL_PREDICT_FALSE((parse_flags & MessageLite::kMergePartial) != 0)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  185|      0|    return true;
  186|      0|  }
  187|      1|  return msg.IsInitializedWithErrors();
  188|      1|}
message_lite.cc:_ZN6google8protobuf12_GLOBAL__N_114as_string_viewEPKvi:
  175|      1|inline absl::string_view as_string_view(const void* data, int size) {
  176|      1|  return absl::string_view(static_cast<const char*>(data), size);
  177|      1|}

_ZN6google8protobuf8internal18MessageGlobalsBase17ToDefaultInstanceIN13sentencepiece14NormalizerSpecEEEPKT_PKv:
  261|      1|  static const T* ToDefaultInstance(const void* globals) {
  262|      1|    return reinterpret_cast<const T*>(globals);
  263|      1|  }
_ZN6google8protobuf8internal18MessageGlobalsBase17ToDefaultInstanceIN13sentencepiece11TrainerSpecEEEPKT_PKv:
  261|      1|  static const T* ToDefaultInstance(const void* globals) {
  262|      1|    return reinterpret_cast<const T*>(globals);
  263|      1|  }
_ZN6google8protobuf11MessageLite11CheckHasBitEjj:
  901|      4|      uint32_t cached_has_bits, uint32_t has_bit_mask) {
  902|      4|    return (cached_has_bits & has_bit_mask) != 0;
  903|      4|  }
_ZN6google8protobuf11MessageLite19internal_visibilityEv:
  788|      1|  static constexpr internal::InternalVisibility internal_visibility() {
  789|      1|    return internal::InternalVisibility{};
  790|      1|  }
_ZNK6google8protobuf11MessageLite8GetArenaEv:
  419|    602|  [[nodiscard]] Arena* GetArena() const { return _internal_metadata_.arena(); }
_ZN6google8protobuf8internal10CachedSizeC2Ev:
  126|      1|  constexpr CachedSize() noexcept : atom_(Scalar{}) {}
_ZNK6google8protobuf11MessageLite15GetTcParseTableEv:
  838|      1|  const internal::TcParseTableBase* GetTcParseTable() const {
  839|      1|    auto* data = GetClassData();
  840|      1|    ABSL_DCHECK(data != nullptr);
  ------------------
  |  |   47|      1|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      1|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      2|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      1|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      2|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      2|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      1|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      1|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 1, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      2|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  841|      1|    return data->GetTcParseTable();
  842|      1|  }
_ZN6google8protobuf11MessageLiteC2EPNS0_5ArenaE:
  851|      1|  explicit MessageLite(Arena* arena) : _internal_metadata_(arena) {}
_ZN6google8protobuf11MessageLite16BatchCheckHasBitEjj:
  906|      1|      uint32_t cached_has_bits, uint32_t batch_has_bits_mask) {
  907|      1|    return (cached_has_bits & batch_has_bits_mask) != 0;
  908|      1|  }
_ZNK6google8protobuf11MessageLite23IsInitializedWithErrorsEv:
  954|      1|  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD bool IsInitializedWithErrors() const {
  955|      1|    if (IsInitialized()) return true;
  ------------------
  |  Branch (955:9): [True: 1, False: 0]
  ------------------
  956|      0|    LogInitializationErrorMessage();
  957|      0|    return false;
  958|      1|  }
_ZNK6google8protobuf8internal9ClassData15GetTcParseTableEv:
  351|      1|inline const TcParseTableBase* ClassData::GetTcParseTable() const {
  352|       |#ifdef PROTOBUF_MESSAGE_GLOBALS
  353|       |  if (ABSL_PREDICT_FALSE(is_dynamic)) {
  354|       |#else
  355|      1|  if (ABSL_PREDICT_FALSE(tc_table == nullptr)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  356|      0|#endif
  357|      0|    ABSL_DCHECK(!is_lite);
  ------------------
  |  |   47|      0|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      0|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  358|      0|    return full().descriptor_methods()->get_tc_table(this);
  359|      0|  }
  360|       |#ifdef PROTOBUF_MESSAGE_GLOBALS
  361|       |  return MessageGlobalsBase::ToParseTableBase(this);
  362|       |#else
  363|      1|  return tc_table;
  364|      1|#endif
  365|      1|}
_ZNK6google8protobuf8internal9ClassData3NewEPNS0_5ArenaE:
 1129|      2|PROTOBUF_ALWAYS_INLINE MessageLite* ClassData::New(Arena* arena) const {
 1130|       |  // Allocate the memory first, to reduce the number of spills.
 1131|       |  // This way we only spill `this` and `arena`.
 1132|      2|  void* mem = message_creator.AllocateMessage(arena);
 1133|      2|  const MessageLite* def = default_instance();
 1134|      2|  return message_creator.PlacementNew(def, def, mem, arena);
 1135|      2|}
_ZNK6google8protobuf8internal14MessageCreator12PlacementNewINS0_11MessageLiteEEEPT_PKS5_S8_PvPNS0_5ArenaE:
 1146|    300|    const MessageLite* prototype_for_copy, void* mem, Arena* arena) const {
 1147|    300|  ABSL_DCHECK_EQ(reinterpret_cast<uintptr_t>(mem) % alignment_, 0u);
  ------------------
  |  |   74|    300|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|    300|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    300|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 300]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    300|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1148|    300|  const Tag as_tag = tag();
 1149|    300|  static_assert(kFunc < 0 && !(kZeroInit < 0) && !(kMemcpy < 0),
 1150|    300|                "Only kFunc must be the only negative value");
 1151|    300|  if (ABSL_PREDICT_FALSE(static_cast<int8_t>(as_tag) < 0)) {
  ------------------
  |  |  190|    300|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 300]
  |  |  |  Branch (190:49): [Folded, False: 300]
  |  |  |  Branch (190:58): [True: 0, False: 300]
  |  |  ------------------
  ------------------
 1152|      0|    PROTOBUF_DEBUG_COUNTER("MessageCreator.Func").Inc();
  ------------------
  |  |  856|      0|  ::google::protobuf::internal::NoopDebugCounter {}
  ------------------
 1153|      0|    return static_cast<MessageLite*>(func_(prototype_for_func, mem, arena));
 1154|      0|  }
 1155|       |
 1156|    300|  char* dst = static_cast<char*>(mem);
 1157|    300|  const size_t size = allocation_size_;
 1158|    300|  const char* src = reinterpret_cast<const char*>(prototype_for_copy);
 1159|       |
 1160|       |  // These are a bit more efficient than calling normal memset/memcpy because:
 1161|       |  //  - We know the minimum size is 16. We have a fallback for when it is not.
 1162|       |  //  - We can "underflow" the buffer because those are the MessageLite bytes
 1163|       |  //    we will set later.
 1164|    300|  if (as_tag == kZeroInit) {
  ------------------
  |  Branch (1164:7): [True: 0, False: 300]
  ------------------
 1165|      0|    PROTOBUF_DEBUG_COUNTER("MessageCreator.ZeroInit").IncLog(size);
  ------------------
  |  |  856|      0|  ::google::protobuf::internal::NoopDebugCounter {}
  ------------------
 1166|       |    // Make sure the input is really all zeros.
 1167|      0|    ABSL_DCHECK(std::all_of(src + sizeof(MessageLite), src + size,
  ------------------
  |  |   47|      0|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      0|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1168|      0|                            [](auto c) { return c == 0; }));
 1169|       |
 1170|      0|    if (sizeof(MessageLite) != 16) {
  ------------------
  |  Branch (1170:9): [Folded, False: 0]
  ------------------
 1171|      0|      memset(dst, 0, size);
 1172|      0|    } else if (size <= 32) {
  ------------------
  |  Branch (1172:16): [True: 0, False: 0]
  ------------------
 1173|      0|      memset(dst + size - 16, 0, 16);
 1174|      0|    } else if (size <= 64) {
  ------------------
  |  Branch (1174:16): [True: 0, False: 0]
  ------------------
 1175|      0|      memset(dst + 16, 0, 16);
 1176|      0|      memset(dst + size - 32, 0, 32);
 1177|      0|    } else {
 1178|      0|      for (size_t offset = 16; offset + 64 < size; offset += 64) {
  ------------------
  |  Branch (1178:32): [True: 0, False: 0]
  ------------------
 1179|      0|        absl::PrefetchToLocalCacheForWrite(dst + offset + 64);
 1180|      0|        memset(dst + offset, 0, 64);
 1181|      0|      }
 1182|      0|      memset(dst + size - 64, 0, 64);
 1183|      0|    }
 1184|    300|  } else {
 1185|    300|    PROTOBUF_DEBUG_COUNTER("MessageCreator.Memcpy").IncLog(size);
  ------------------
  |  |  856|    300|  ::google::protobuf::internal::NoopDebugCounter {}
  ------------------
 1186|    300|    ABSL_DCHECK_EQ(+as_tag, +kMemcpy);
  ------------------
  |  |   74|    300|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|    300|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    300|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 300]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    300|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1187|       |
 1188|    300|    if (sizeof(MessageLite) != 16) {
  ------------------
  |  Branch (1188:9): [Folded, False: 300]
  ------------------
 1189|      0|      memcpy(dst, src, size);
 1190|    300|    } else if (size <= 32) {
  ------------------
  |  Branch (1190:16): [True: 0, False: 300]
  ------------------
 1191|      0|      memcpy(dst + size - 16, src + size - 16, 16);
 1192|    300|    } else if (size <= 64) {
  ------------------
  |  Branch (1192:16): [True: 298, False: 2]
  ------------------
 1193|    298|      memcpy(dst + 16, src + 16, 16);
 1194|    298|      memcpy(dst + size - 32, src + size - 32, 32);
 1195|    298|    } else {
 1196|      5|      for (size_t offset = 16; offset + 64 < size; offset += 64) {
  ------------------
  |  Branch (1196:32): [True: 3, False: 2]
  ------------------
 1197|      3|        absl::PrefetchToLocalCache(src + offset + 64);
 1198|      3|        absl::PrefetchToLocalCacheForWrite(dst + offset + 64);
 1199|      3|        memcpy(dst + offset, src + offset, 64);
 1200|      3|      }
 1201|      2|      memcpy(dst + size - 64, src + size - 64, 64);
 1202|      2|    }
 1203|    300|  }
 1204|       |
 1205|       |  // The second memcpy overwrites part of the first, but the compiler should
 1206|       |  // avoid the double-write. It's easier than trying to avoid the overlap.
 1207|    300|  memcpy(dst, static_cast<const void*>(prototype_for_copy),
 1208|    300|         sizeof(MessageLite));
 1209|    300|  memcpy(dst + PROTOBUF_FIELD_OFFSET(MessageLite, _internal_metadata_), &arena,
  ------------------
  |  |  311|    300|  _Pragma("clang diagnostic push")                           \
  |  |  312|    300|  _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \
  |  |  313|    300|  __builtin_offsetof(TYPE, FIELD)                            \
  |  |  314|    300|  _Pragma("clang diagnostic pop")
  ------------------
 1210|    300|         sizeof(arena));
 1211|    300|  return Launder(reinterpret_cast<MessageLite*>(mem));
 1212|    300|}
_ZN6google8protobuf8internal18MessageGlobalsBase17ToDefaultInstanceIN13sentencepiece24ModelProto_SentencePieceEEEPKT_PKv:
  261|    298|  static const T* ToDefaultInstance(const void* globals) {
  262|    298|    return reinterpret_cast<const T*>(globals);
  263|    298|  }
_ZN6google8protobuf8internal18MessageGlobalsBase17ToDefaultInstanceIN13sentencepiece10ModelProtoEEEPKT_PKv:
  261|      1|  static const T* ToDefaultInstance(const void* globals) {
  262|      1|    return reinterpret_cast<const T*>(globals);
  263|      1|  }
_ZN6google8protobuf11MessageLite9ParseFromILNS1_10ParseFlagsE1ENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEbRKT0_:
 1088|      1|    const T& input) {
 1089|      1|  if (flags & kParse) Clear();
  ------------------
  |  Branch (1089:7): [True: 1, Folded]
  ------------------
 1090|      1|  constexpr bool alias = (flags & kMergeWithAliasing) != 0;
 1091|      1|  const internal::TcParseTableBase* tc_table;
 1092|      1|  PROTOBUF_ALWAYS_INLINE_CALL tc_table = GetTcParseTable();
  ------------------
  |  |  174|      1|#define PROTOBUF_ALWAYS_INLINE_CALL [[clang::always_inline]]
  ------------------
 1093|      1|  return internal::MergeFromImpl<alias>(input, this, tc_table, flags);
 1094|      1|}

_ZNK6google8protobuf8internal16InternalMetadata5arenaEv:
   67|    602|  PROTOBUF_NDEBUG_INLINE Arena* arena() const {
   68|    602|    if (ABSL_PREDICT_FALSE(have_unknown_fields())) {
  ------------------
  |  |  190|    602|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 602]
  |  |  |  Branch (190:49): [Folded, False: 602]
  |  |  |  Branch (190:58): [True: 0, False: 602]
  |  |  ------------------
  ------------------
   69|      0|      return PtrValue<ContainerBase>()->arena;
   70|    602|    } else {
   71|    602|      return PtrValue<Arena>();
   72|    602|    }
   73|    602|  }
_ZNK6google8protobuf8internal16InternalMetadata19have_unknown_fieldsEv:
   75|    603|  PROTOBUF_NDEBUG_INLINE bool have_unknown_fields() const {
   76|    603|    return HasUnknownFieldsTag();
   77|    603|  }
_ZNK6google8protobuf8internal16InternalMetadata19HasUnknownFieldsTagEv:
  143|    603|  PROTOBUF_ALWAYS_INLINE bool HasUnknownFieldsTag() const {
  144|    603|    return ptr_ & kUnknownFieldsTagMask;
  145|    603|  }
_ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS0_5ArenaEEEPT_v:
  148|    602|  U* PtrValue() const {
  149|    602|    if constexpr (std::is_same_v<U, Arena>) {
  150|       |      // No mask to remove.
  151|    602|      ABSL_DCHECK_EQ(ptr_ & kPtrTagMask, 0);
  ------------------
  |  |   74|    602|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|    602|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    602|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 602]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    602|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  152|    602|      return reinterpret_cast<U*>(ptr_);
  153|       |    } else {
  154|       |      static_assert(kPtrTagMask == 1);
  155|       |      ABSL_DCHECK_EQ(ptr_ & kPtrTagMask, kPtrTagMask);
  156|       |      // We can remove the mask via -1, which is smaller asm and can be merged
  157|       |      // with other arithmetic operations.
  158|       |      // Eg PtrValue<Container>()->unknown_fields can merge the offset into the
  159|       |      // mask removal.
  160|       |      return reinterpret_cast<U*>(ptr_ - kPtrTagMask);
  161|       |    }
  162|    602|  }
_ZN6google8protobuf8internal16InternalMetadataC2EPNS0_5ArenaE:
   48|      1|  explicit InternalMetadata(Arena* arena) {
   49|      1|    ptr_ = reinterpret_cast<intptr_t>(arena);
   50|      1|  }
_ZN6google8protobuf8internal16InternalMetadata5ClearINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvv:
  128|      1|  PROTOBUF_NDEBUG_INLINE void Clear() {
  129|      1|    if (ABSL_PREDICT_FALSE(have_unknown_fields())) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  130|      0|      DoClear<T>();
  131|      0|    }
  132|      1|  }

_ZN6google8protobuf8internal18EpsCopyInputStream28IsRequestedLessThanOrEqualToEii:
   90|    298|                                                      int available) {
   91|    298|  return static_cast<int64_t>(static_cast<uint32_t>(requested)) <=
   92|    298|         static_cast<int64_t>(available);
   93|    298|}
_ZN6google8protobuf8internal18EpsCopyInputStream14CanReadFromPtrEiPKc:
   95|    298|bool EpsCopyInputStream::CanReadFromPtr(int requested, const char* ptr) {
   96|    298|  return IsRequestedLessThanOrEqualTo(requested, BytesAvailable(ptr));
   97|    298|}
_ZN6google8protobuf8internal18EpsCopyInputStream10NextBufferEii:
  114|      1|const char* EpsCopyInputStream::NextBuffer(int overrun, int depth) {
  115|      1|  if (next_chunk_ == nullptr) return nullptr;  // We've reached end of stream.
  ------------------
  |  Branch (115:7): [True: 0, False: 1]
  ------------------
  116|      1|  if (next_chunk_ != patch_buffer_) {
  ------------------
  |  Branch (116:7): [True: 0, False: 1]
  ------------------
  117|      0|    ABSL_DCHECK(size_ > kSlopBytes);
  ------------------
  |  |   47|      0|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      0|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  118|       |    // The chunk is large enough to be used directly
  119|      0|    buffer_end_ = next_chunk_ + size_ - kSlopBytes;
  120|      0|    auto res = next_chunk_;
  121|      0|    next_chunk_ = patch_buffer_;
  122|      0|    if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
  ------------------
  |  Branch (122:9): [True: 0, False: 0]
  ------------------
  123|      0|    return res;
  124|      0|  }
  125|       |  // Move the slop bytes of previous buffer to start of the patch buffer.
  126|       |  // Note we must use memmove because the previous buffer could be part of
  127|       |  // patch_buffer_.
  128|      1|  std::memmove(patch_buffer_, buffer_end_, kSlopBytes);
  129|      1|  if (overall_limit_ > 0 &&
  ------------------
  |  Branch (129:7): [True: 0, False: 1]
  ------------------
  130|      0|      (depth < 0 || !ParseEndsInSlopRegion(patch_buffer_, overrun, depth))) {
  ------------------
  |  Branch (130:8): [True: 0, False: 0]
  |  Branch (130:21): [True: 0, False: 0]
  ------------------
  131|      0|    const void* data;
  132|       |    // ZeroCopyInputStream indicates Next may return 0 size buffers. Hence
  133|       |    // we loop.
  134|      0|    while (StreamNext(&data)) {
  ------------------
  |  Branch (134:12): [True: 0, False: 0]
  ------------------
  135|      0|      if (size_ > kSlopBytes) {
  ------------------
  |  Branch (135:11): [True: 0, False: 0]
  ------------------
  136|       |        // We got a large chunk
  137|      0|        std::memcpy(patch_buffer_ + kSlopBytes, data, kSlopBytes);
  138|      0|        next_chunk_ = static_cast<const char*>(data);
  139|      0|        buffer_end_ = patch_buffer_ + kSlopBytes;
  140|      0|        if (aliasing_ >= kNoDelta) aliasing_ = kOnPatch;
  ------------------
  |  Branch (140:13): [True: 0, False: 0]
  ------------------
  141|      0|        return patch_buffer_;
  142|      0|      } else if (size_ > 0) {
  ------------------
  |  Branch (142:18): [True: 0, False: 0]
  ------------------
  143|      0|        std::memcpy(patch_buffer_ + kSlopBytes, data, size_);
  144|      0|        next_chunk_ = patch_buffer_;
  145|      0|        buffer_end_ = patch_buffer_ + size_;
  146|      0|        if (aliasing_ >= kNoDelta) aliasing_ = kOnPatch;
  ------------------
  |  Branch (146:13): [True: 0, False: 0]
  ------------------
  147|      0|        return patch_buffer_;
  148|      0|      }
  149|      0|      ABSL_DCHECK(size_ == 0) << size_;
  ------------------
  |  |   47|      0|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      0|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  150|      0|    }
  151|      0|    overall_limit_ = 0;  // Next failed, no more needs for next
  152|      0|  }
  153|       |  // End of stream or array
  154|      1|  if (aliasing_ == kNoDelta) {
  ------------------
  |  Branch (154:7): [True: 0, False: 1]
  ------------------
  155|       |    // If there is no more block and aliasing is true, the previous block
  156|       |    // is still valid and we can alias. We have users relying on string_view's
  157|       |    // obtained from protos to outlive the proto, when the parse was from an
  158|       |    // array. This guarantees string_view's are always aliased if parsed from
  159|       |    // an array.
  160|      0|    aliasing_ = reinterpret_cast<std::uintptr_t>(buffer_end_) -
  161|      0|                reinterpret_cast<std::uintptr_t>(patch_buffer_);
  162|      0|  }
  163|      1|  next_chunk_ = nullptr;
  164|      1|  buffer_end_ = patch_buffer_ + kSlopBytes;
  165|      1|  size_ = 0;
  166|      1|  return patch_buffer_;
  167|      1|}
_ZN6google8protobuf8internal18EpsCopyInputStream12DoneFallbackEii:
  184|      1|                                                              int depth) {
  185|       |  // Did we exceeded the limit (parse error).
  186|      1|  if (ABSL_PREDICT_FALSE(overrun > limit_)) return {nullptr, true};
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  187|      1|  ABSL_DCHECK(overrun != limit_);  // Guaranteed by caller.
  ------------------
  |  |   47|      1|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      1|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      3|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      1|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      2|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      2|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      1|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      1|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 1, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      3|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      3|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  188|      1|  ABSL_DCHECK(overrun < limit_);   // Follows from above
  ------------------
  |  |   47|      1|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      1|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      3|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      1|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      2|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      2|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      1|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      1|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 1, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      3|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      3|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  189|       |  // TODO Instead of this dcheck we could just assign, and remove
  190|       |  // updating the limit_end from PopLimit, ie.
  191|       |  // limit_end_ = buffer_end_ + (std::min)(0, limit_);
  192|       |  // if (ptr < limit_end_) return {ptr, false};
  193|      1|  ABSL_DCHECK(limit_end_ == buffer_end_ + (std::min)(0, limit_));
  ------------------
  |  |   47|      1|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      1|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      3|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      1|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      2|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      2|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      1|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      1|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 1, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      3|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      3|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  194|       |  // At this point we know the following assertion holds.
  195|      1|  ABSL_DCHECK_GT(limit_, 0);
  ------------------
  |  |   84|      1|  ABSL_LOG_INTERNAL_DCHECK_GT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   97|      1|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      1|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 1]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      1|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  196|      1|  ABSL_DCHECK(limit_end_ == buffer_end_);  // because limit_ > 0
  ------------------
  |  |   47|      1|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      1|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      2|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      1|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      2|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      2|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      1|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      1|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 1, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      2|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  197|      1|  const char* p;
  198|      1|  do {
  199|       |    // We are past the end of buffer_end_, in the slop region.
  200|      1|    ABSL_DCHECK_GE(overrun, 0);
  ------------------
  |  |   82|      1|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|      1|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      1|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 1]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      1|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  201|      1|    p = NextBuffer(overrun, depth);
  202|      1|    if (p == nullptr) {
  ------------------
  |  Branch (202:9): [True: 0, False: 1]
  ------------------
  203|       |      // We are at the end of the stream
  204|      0|      if (ABSL_PREDICT_FALSE(overrun != 0)) return {nullptr, true};
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  205|      0|      ABSL_DCHECK_GT(limit_, 0);
  ------------------
  |  |   84|      0|  ABSL_LOG_INTERNAL_DCHECK_GT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   97|      0|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 0]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  206|      0|      limit_end_ = buffer_end_;
  207|       |      // Distinguish ending on a pushed limit or ending on end-of-stream.
  208|      0|      SetEndOfStream();
  209|      0|      return {buffer_end_, true};
  210|      0|    }
  211|      1|    limit_ -= buffer_end_ - p;  // Adjust limit_ relative to new anchor
  212|      1|    p += overrun;
  213|      1|    overrun = p - buffer_end_;
  214|      1|  } while (overrun >= 0);
  ------------------
  |  Branch (214:12): [True: 0, False: 1]
  ------------------
  215|      1|  limit_end_ = buffer_end_ + std::min(0, limit_);
  216|      1|  return {p, false};
  217|      1|}

_ZN6google8protobuf8internal18EpsCopyInputStreamC2Eb:
  121|      1|      : aliasing_(enable_aliasing ? kOnPatch : kNoAliasing) {}
  ------------------
  |  Branch (121:19): [True: 0, False: 1]
  ------------------
_ZN6google8protobuf8internal18EpsCopyInputStream10LimitTokenC2Ev:
  140|    300|    LimitToken() { internal::PoisonMemoryRegion(&token_, sizeof(token_)); }
_ZN6google8protobuf8internal18EpsCopyInputStream10LimitTokenC2Ei:
  142|    300|    explicit LimitToken(int token) : token_(token) {
  143|    300|      internal::UnpoisonMemoryRegion(&token_, sizeof(token_));
  144|    300|    }
_ZN6google8protobuf8internal18EpsCopyInputStream10LimitTokenC2EOS3_:
  149|    300|    LimitToken(LimitToken&& other) { *this = std::move(other); }
_ZN6google8protobuf8internal18EpsCopyInputStream10LimitTokenaSEOS3_:
  151|    600|    LimitToken& operator=(LimitToken&& other) {
  152|    600|      internal::UnpoisonMemoryRegion(&token_, sizeof(token_));
  153|    600|      token_ = other.token_;
  154|    600|      internal::PoisonMemoryRegion(&other.token_, sizeof(token_));
  155|    600|      return *this;
  156|    600|    }
_ZN6google8protobuf8internal18EpsCopyInputStream10LimitTokenD2Ev:
  158|    900|    ~LimitToken() { internal::UnpoisonMemoryRegion(&token_, sizeof(token_)); }
_ZNO6google8protobuf8internal18EpsCopyInputStream10LimitToken5tokenEv:
  160|    300|    int token() && {
  161|    300|      int t = token_;
  162|    300|      internal::PoisonMemoryRegion(&token_, sizeof(token_));
  163|    300|      return t;
  164|    300|    }
_ZN6google8protobuf8internal18EpsCopyInputStream9PushLimitEPKci:
  171|    300|  [[nodiscard]] LimitToken PushLimit(const char* ptr, int limit) {
  172|    300|    ABSL_DCHECK(limit >= 0 && limit <= INT_MAX - kSlopBytes);
  ------------------
  |  |   47|    300|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|    300|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|    600|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|    300|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|    600|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|    600|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 300, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|    300|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 300]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|    300|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 300, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|    600|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|    600|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  173|       |    // This add is safe due to the invariant above, because
  174|       |    // ptr - buffer_end_ <= kSlopBytes.
  175|    300|    limit += static_cast<int>(ptr - buffer_end_);
  176|    300|    if (ABSL_PREDICT_TRUE(limit <= 0)) {
  ------------------
  |  |  191|    300|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 299, False: 1]
  |  |  |  Branch (191:48): [Folded, False: 300]
  |  |  |  Branch (191:57): [True: 299, False: 1]
  |  |  ------------------
  ------------------
  177|    299|      limit_end_ = buffer_end_ + limit;
  178|    299|    } else {
  179|      1|      limit_end_ = buffer_end_;
  180|      1|    }
  181|    300|    auto old_limit = limit_;
  182|    300|    limit_ = limit;
  183|    300|    return LimitToken(old_limit - limit);
  184|    300|  }
_ZN6google8protobuf8internal18EpsCopyInputStream8PopLimitENS2_10LimitTokenE:
  186|    300|  [[nodiscard]] bool PopLimit(LimitToken delta) {
  187|       |    // We must update the limit first before the early return. Otherwise, we can
  188|       |    // end up with an invalid limit and it can lead to integer overflows.
  189|    300|    int old_limit = limit_ + std::move(delta).token();
  190|    300|    limit_ = old_limit;
  191|    300|    if (ABSL_PREDICT_FALSE(!EndedAtLimit())) return false;
  ------------------
  |  |  190|    300|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 300]
  |  |  |  Branch (190:49): [Folded, False: 300]
  |  |  |  Branch (190:58): [True: 0, False: 300]
  |  |  ------------------
  ------------------
  192|       |    // TODO We could remove this line and hoist the code to
  193|       |    // DoneFallback. Study the perf/bin-size effects.
  194|    300|    if (ABSL_PREDICT_TRUE(old_limit <= 0)) {
  ------------------
  |  |  191|    300|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 2, False: 298]
  |  |  |  Branch (191:48): [Folded, False: 300]
  |  |  |  Branch (191:57): [True: 2, False: 298]
  |  |  ------------------
  ------------------
  195|      2|      limit_end_ = buffer_end_ + old_limit;
  196|    298|    } else {
  197|    298|      limit_end_ = buffer_end_;
  198|    298|    }
  199|    300|    return true;
  200|    300|  }
_ZN6google8protobuf8internal18EpsCopyInputStream10ReadStringEPKciPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  209|    298|                                       std::string* s) {
  210|    298|    if (CanReadFromPtr(size, ptr)) {
  ------------------
  |  Branch (210:9): [True: 298, False: 0]
  ------------------
  211|       |      // Fundamentally we just want to do assign to the string.
  212|       |      // However micro-benchmarks regress on string reading cases. So we copy
  213|       |      // the same logic from the old CodedInputStream ReadString. Note: as of
  214|       |      // Apr 2021, this is still a significant win over `assign()`.
  215|    298|      absl::strings_internal::STLStringResizeUninitialized(s, size);
  216|    298|      char* z = &(*s)[0];
  217|    298|      memcpy(z, ptr, size);
  218|    298|      return ptr + size;
  219|    298|    }
  220|      0|    return ReadStringFallback(ptr, size, s);
  221|    298|  }
_ZNK6google8protobuf8internal18EpsCopyInputStream7LastTagEv:
  302|    302|  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD uint32_t LastTag() const {
  303|    302|    return last_tag_minus_1_ + 1;
  304|    302|  }
_ZNK6google8protobuf8internal18EpsCopyInputStream12EndedAtLimitEv:
  310|    301|  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD bool EndedAtLimit() const {
  311|    301|    return last_tag_minus_1_ == 0;
  312|    301|  }
_ZN6google8protobuf8internal18EpsCopyInputStream13DataAvailableEPKc:
  336|  1.16k|  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD bool DataAvailable(const char* ptr) {
  337|  1.16k|    return ptr < limit_end_;
  338|  1.16k|  }
_ZNK6google8protobuf8internal18EpsCopyInputStream14BytesAvailableEPKc:
  341|    298|      const char* ptr) const {
  342|    298|    ABSL_DCHECK_NE(ptr, nullptr);
  ------------------
  |  |   76|    298|  ABSL_LOG_INTERNAL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   89|    298|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    298|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 298]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    298|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  343|    298|    ptrdiff_t available = buffer_end_ + kSlopBytes - ptr;
  344|    298|    ABSL_DCHECK_GE(available, 0);
  ------------------
  |  |   82|    298|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|    298|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    298|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 298]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    298|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  345|    298|    ABSL_DCHECK_LE(available, INT_MAX);
  ------------------
  |  |   78|    298|  ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   91|    298|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    298|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 298]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    298|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  346|    298|    return static_cast<int>(available);
  347|    298|  }
_ZN6google8protobuf8internal18EpsCopyInputStream18WireFormatNoOpSink5FlushEPKc:
  455|    302|    void Flush(const char* p) {}
_ZN6google8protobuf8internal18EpsCopyInputStream18WireFormatNoOpSink5ResetEPKc:
  457|    302|    void Reset(const char* p) {}
_ZN6google8protobuf8internal18EpsCopyInputStream8InitFromENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  489|      1|  const char* InitFrom(absl::string_view flat) {
  490|      1|    overall_limit_ = 0;
  491|      1|    if (flat.size() > kSlopBytes) {
  ------------------
  |  Branch (491:9): [True: 1, False: 0]
  ------------------
  492|      1|      limit_ = kSlopBytes;
  493|      1|      limit_end_ = buffer_end_ = flat.data() + flat.size() - kSlopBytes;
  494|      1|      next_chunk_ = patch_buffer_;
  495|      1|      if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
  ------------------
  |  Branch (495:11): [True: 0, False: 1]
  ------------------
  496|      1|      return flat.data();
  497|      1|    } else {
  498|      0|      if (!flat.empty()) {
  ------------------
  |  Branch (498:11): [True: 0, False: 0]
  ------------------
  499|      0|        std::memcpy(patch_buffer_, flat.data(), flat.size());
  500|      0|      }
  501|      0|      limit_ = 0;
  502|      0|      limit_end_ = buffer_end_ = patch_buffer_ + flat.size();
  503|      0|      next_chunk_ = nullptr;
  504|      0|      if (aliasing_ == kOnPatch) {
  ------------------
  |  Branch (504:11): [True: 0, False: 0]
  ------------------
  505|      0|        aliasing_ = reinterpret_cast<std::uintptr_t>(flat.data()) -
  506|      0|                    reinterpret_cast<std::uintptr_t>(patch_buffer_);
  507|      0|      }
  508|      0|      return patch_buffer_;
  509|      0|    }
  510|      1|  }
_ZN6google8protobuf8internal12ParseContext4DoneEPPKc:
  729|    603|  PROTOBUF_FUTURE_ADD_EARLY_NODISCARD bool Done(const char** ptr) {
  730|    603|    WireFormatNoOpSink sink;
  731|    603|    return DoneWithCheck(ptr, group_depth_, sink);
  732|    603|  }
_ZN6google8protobuf8internal12EndianHelperILi1EE4LoadEPKv:
  871|    599|  static uint8_t Load(const void* p) { return *static_cast<const uint8_t*>(p); }
_ZN6google8protobuf8internal12EndianHelperILi2EE4LoadEPKv:
  876|    864|  static uint16_t Load(const void* p) {
  877|    864|    uint16_t tmp;
  878|    864|    std::memcpy(&tmp, p, 2);
  879|    864|    return little_endian::ToHost(tmp);
  880|    864|  }
_ZN6google8protobuf8internal12EndianHelperILi4EE4LoadEPKv:
  885|    298|  static uint32_t Load(const void* p) {
  886|    298|    uint32_t tmp;
  887|    298|    std::memcpy(&tmp, p, 4);
  888|    298|    return little_endian::ToHost(tmp);
  889|    298|  }
_ZN6google8protobuf8internal10RotateLeftImEET_S3_i:
 1247|      1|    RotateLeft(T x, int s) noexcept {
 1248|      1|  return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) |
 1249|      1|         static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
 1250|      1|}
_ZN6google8protobuf8internal26RotRight7AndReplaceLowByteEmc:
 1253|      1|RotRight7AndReplaceLowByte(uint64_t res, const char byte) {
 1254|       |  // TODO: remove the inline assembly
 1255|      1|#if defined(__x86_64__) && defined(__GNUC__)
 1256|       |  // This will only use one register for `res`.
 1257|       |  // `byte` comes as a reference to allow the compiler to generate code like:
 1258|       |  //
 1259|       |  //   rorq    $7, %rcx
 1260|       |  //   movb    1(%rax), %cl
 1261|       |  //
 1262|       |  // which avoids loading the incoming bytes into a separate register first.
 1263|      1|  asm("ror $7,%0\n\t"
 1264|      1|      "movb %1,%b0"
 1265|      1|      : "+r"(res)
 1266|      1|      : "m"(byte));
 1267|       |#else
 1268|       |  res = RotateLeft(res, -7);
 1269|       |  res = res & ~0xFF;
 1270|       |  res |= 0xFF & byte;
 1271|       |#endif
 1272|      1|  return res;
 1273|      1|}
_ZN6google8protobuf8internal14ReadTagInlinedEPKcPj:
 1277|      1|                                                  uint32_t* out) {
 1278|      1|  uint64_t res = 0xFF & ptr[0];
 1279|      1|  if (ABSL_PREDICT_FALSE(res >= 128)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 1280|      1|    res = RotRight7AndReplaceLowByte(res, ptr[1]);
 1281|      1|    if (ABSL_PREDICT_FALSE(res & 0x80)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1282|      0|      res = RotRight7AndReplaceLowByte(res, ptr[2]);
 1283|      0|      if (ABSL_PREDICT_FALSE(res & 0x80)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1284|      0|        res = RotRight7AndReplaceLowByte(res, ptr[3]);
 1285|      0|        if (ABSL_PREDICT_FALSE(res & 0x80)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1286|       |          // Note: this wouldn't work if res were 32-bit,
 1287|       |          // because then replacing the low byte would overwrite
 1288|       |          // the bottom 4 bits of the result.
 1289|      0|          res = RotRight7AndReplaceLowByte(res, ptr[4]);
 1290|      0|          if (ABSL_PREDICT_FALSE(res & 0x80)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1291|       |            // The proto format does not permit longer than 5-byte encodings for
 1292|       |            // tags.
 1293|      0|            *out = 0;
 1294|      0|            return nullptr;
 1295|      0|          }
 1296|      0|          *out = static_cast<uint32_t>(RotateLeft(res, 28));
 1297|      0|#if defined(__GNUC__)
 1298|       |          // Note: this asm statement prevents the compiler from
 1299|       |          // trying to share the "return ptr + constant" among all
 1300|       |          // branches.
 1301|      0|          asm("" : "+r"(ptr));
 1302|      0|#endif
 1303|      0|          return ptr + 5;
 1304|      0|        }
 1305|      0|        *out = static_cast<uint32_t>(RotateLeft(res, 21));
 1306|      0|        return ptr + 4;
 1307|      0|      }
 1308|      0|      *out = static_cast<uint32_t>(RotateLeft(res, 14));
 1309|      0|      return ptr + 3;
 1310|      0|    }
 1311|      1|    *out = static_cast<uint32_t>(RotateLeft(res, 7));
 1312|      1|    return ptr + 2;
 1313|      1|  }
 1314|      0|  *out = static_cast<uint32_t>(res);
 1315|      0|  return ptr + 1;
 1316|      1|}
_ZN6google8protobuf8internal8ReadSizeEPPKc:
 1374|    598|inline uint32_t ReadSize(const char** pp) {
 1375|    598|  auto p = *pp;
 1376|    598|  uint32_t res = static_cast<uint8_t>(p[0]);
 1377|    598|  if (res < 128) {
  ------------------
  |  Branch (1377:7): [True: 598, False: 0]
  ------------------
 1378|    598|    *pp = p + 1;
 1379|    598|    return res;
 1380|    598|  }
 1381|      0|  auto x = ReadSizeFallback(p, res);
 1382|      0|  *pp = x.first;
 1383|      0|  return x.second;
 1384|    598|}
_ZN6google8protobuf8internal12ParseContext35ReadSizeAndPushLimitAndDepthInlinedEPKcPNS1_18EpsCopyInputStream10LimitTokenE:
 1454|    300|    const char* ptr, LimitToken* old_limit) {
 1455|    300|  int size = ReadSize(&ptr);
 1456|    300|  if (ABSL_PREDICT_FALSE(!ptr) || depth_ <= 0) {
  ------------------
  |  |  190|    600|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 300]
  |  |  |  Branch (190:49): [Folded, False: 300]
  |  |  |  Branch (190:58): [True: 0, False: 300]
  |  |  ------------------
  ------------------
  |  Branch (1456:35): [True: 0, False: 300]
  ------------------
 1457|      0|    return nullptr;
 1458|      0|  }
 1459|    300|  *old_limit = PushLimit(ptr, size);
 1460|    300|  --depth_;
 1461|    300|  return ptr;
 1462|    300|}
_ZN6google8protobuf8internal18EpsCopyInputStream13DoneWithCheckINS2_18WireFormatNoOpSinkEEEbPPKciRT_:
  465|    603|  bool DoneWithCheck(const char** ptr, int d, SinkT& sink) {
  466|    603|    ABSL_DCHECK(*ptr);
  ------------------
  |  |   47|    603|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|    603|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  1.20k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|    603|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|  1.20k|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|  1.20k|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 603, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|    603|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 603]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|    603|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 603, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|  1.20k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|  1.20k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  467|    603|    if (ABSL_PREDICT_TRUE(*ptr < limit_end_)) return false;
  ------------------
  |  |  191|    603|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 301, False: 302]
  |  |  |  Branch (191:48): [Folded, False: 603]
  |  |  |  Branch (191:57): [True: 301, False: 302]
  |  |  ------------------
  ------------------
  468|    302|    int overrun = static_cast<int>(*ptr - buffer_end_);
  469|    302|    ABSL_DCHECK_LE(overrun, kSlopBytes);  // Guaranteed by parse loop.
  ------------------
  |  |   78|    302|  ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   91|    302|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    302|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 302]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    302|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  470|    302|    if (overrun ==
  ------------------
  |  Branch (470:9): [True: 301, False: 1]
  ------------------
  471|    302|        limit_) {  //  No need to flip buffers if we ended on a limit.
  472|       |      // Flush up to *ptr since we're done with it.
  473|    301|      sink.Flush(*ptr);
  474|    301|      sink.Reset(*ptr);
  475|       |      // If we actually overrun the buffer and next_chunk_ is null, it means
  476|       |      // the stream ended and we passed the stream end.
  477|    301|      if (overrun > 0 && next_chunk_ == nullptr) *ptr = nullptr;
  ------------------
  |  Branch (477:11): [True: 0, False: 301]
  |  Branch (477:26): [True: 0, False: 0]
  ------------------
  478|    301|      return true;
  479|    301|    }
  480|       |    // Flush up to *ptr before updating it.
  481|      1|    sink.Flush(*ptr);
  482|      1|    auto res = DoneFallback(overrun, d);
  483|      1|    *ptr = res.first;
  484|       |    // Reset the sink to the new start pointer.
  485|      1|    sink.Reset(res.first);
  486|      1|    return res.second;
  487|    302|  }
_ZN6google8protobuf8internal13UnalignedLoadItEET_PKc:
  902|    864|PROTOBUF_FUTURE_ADD_EARLY_NODISCARD T UnalignedLoad(const char* p) {
  903|    864|  auto tmp = EndianHelper<sizeof(T)>::Load(p);
  904|    864|  T res;
  905|    864|  memcpy(&res, &tmp, sizeof(T));
  906|    864|  return res;
  907|    864|}
_ZN6google8protobuf8internal13UnalignedLoadIjEET_PKc:
  902|    298|PROTOBUF_FUTURE_ADD_EARLY_NODISCARD T UnalignedLoad(const char* p) {
  903|    298|  auto tmp = EndianHelper<sizeof(T)>::Load(p);
  904|    298|  T res;
  905|    298|  memcpy(&res, &tmp, sizeof(T));
  906|    298|  return res;
  907|    298|}
_ZN6google8protobuf8internal13UnalignedLoadIhEET_PKc:
  902|    599|PROTOBUF_FUTURE_ADD_EARLY_NODISCARD T UnalignedLoad(const char* p) {
  903|    599|  auto tmp = EndianHelper<sizeof(T)>::Load(p);
  904|    599|  T res;
  905|    599|  memcpy(&res, &tmp, sizeof(T));
  906|    599|  return res;
  907|    599|}
_ZN6google8protobuf8internal12ParseContext27ParseLengthDelimitedInlinedIZNS1_8TcParser27SingularParseMessageAuxImplIhLb0ELb1EEEPKcPNS0_11MessageLiteES7_PS2_NS1_11TcFieldDataEPKNS1_16TcParseTableBaseEmEUlS7_E_EES7_S7_RKT_:
 1421|      2|ParseContext::ParseLengthDelimitedInlined(const char* ptr, const Func& func) {
 1422|      2|  LimitToken old;
 1423|      2|  ptr = ReadSizeAndPushLimitAndDepthInlined(ptr, &old);
 1424|      2|  if (ptr == nullptr) return ptr;
  ------------------
  |  Branch (1424:7): [True: 0, False: 2]
  ------------------
 1425|      2|  auto old_depth = depth_;
 1426|      2|  PROTOBUF_ALWAYS_INLINE_CALL ptr = func(ptr);
  ------------------
  |  |  174|      2|#define PROTOBUF_ALWAYS_INLINE_CALL [[clang::always_inline]]
  ------------------
 1427|      2|  if (ptr != nullptr) ABSL_DCHECK_EQ(old_depth, depth_);
  ------------------
  |  |   74|      2|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|      2|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      2|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 2]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      2|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1427:7): [True: 2, False: 0]
  ------------------
 1428|      2|  depth_++;
 1429|      2|  if (!PopLimit(std::move(old))) return nullptr;
  ------------------
  |  Branch (1429:7): [True: 0, False: 2]
  ------------------
 1430|      2|  return ptr;
 1431|      2|}
_ZN6google8protobuf8internal12ParseContext27ParseLengthDelimitedInlinedIZNS1_8TcParser27RepeatedParseMessageAuxImplIhLb0ELb1EEEPKcPNS0_11MessageLiteES7_PS2_NS1_11TcFieldDataEPKNS1_16TcParseTableBaseEmEUlS7_E_EES7_S7_RKT_:
 1421|    298|ParseContext::ParseLengthDelimitedInlined(const char* ptr, const Func& func) {
 1422|    298|  LimitToken old;
 1423|    298|  ptr = ReadSizeAndPushLimitAndDepthInlined(ptr, &old);
 1424|    298|  if (ptr == nullptr) return ptr;
  ------------------
  |  Branch (1424:7): [True: 0, False: 298]
  ------------------
 1425|    298|  auto old_depth = depth_;
 1426|    298|  PROTOBUF_ALWAYS_INLINE_CALL ptr = func(ptr);
  ------------------
  |  |  174|    298|#define PROTOBUF_ALWAYS_INLINE_CALL [[clang::always_inline]]
  ------------------
 1427|    298|  if (ptr != nullptr) ABSL_DCHECK_EQ(old_depth, depth_);
  ------------------
  |  |   74|    298|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|    298|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    298|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 298]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    298|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1427:7): [True: 298, False: 0]
  ------------------
 1428|    298|  depth_++;
 1429|    298|  if (!PopLimit(std::move(old))) return nullptr;
  ------------------
  |  Branch (1429:7): [True: 0, False: 298]
  ------------------
 1430|    298|  return ptr;
 1431|    298|}
_ZN6google8protobuf8internal12ParseContextC2IJRNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEEibPPKcDpOT_:
  697|      1|      : EpsCopyInputStream(aliasing), depth_(depth) {
  698|      1|    *start = InitFrom(std::forward<T>(args)...);
  699|      1|  }

_ZN6google8protobuf8internal8TSanReadEPKv:
  730|  6.63k|PROTOBUF_ALWAYS_INLINE void TSanRead(const void*) {}
_ZN6google8protobuf8internal9TSanWriteEPKv:
  731|      1|PROTOBUF_ALWAYS_INLINE void TSanWrite(const void*) {}
_ZN6google8protobuf8internal8AllocateEm:
  141|    308|PROTOBUF_ALWAYS_INLINE PROTOBUF_MALLOC void* Allocate(size_t size) {
  142|    308|#if ABSL_HAVE_BUILTIN(__builtin_operator_new)
  143|       |  // Allows the compiler to merge or optimize away the allocation even if it
  144|       |  // would violate the observability guarantees of ::operator new.
  145|    308|  return __builtin_operator_new(size);
  146|       |#else
  147|       |  return ::operator new(size);
  148|       |#endif
  149|    308|}
_ZN6google8protobuf8internal16NoopDebugCounter6IncLogEm:
  824|    300|  constexpr void IncLog(uint64_t) {}
_ZNK6google8protobuf8internal26GlobalEmptyStringConstexpr4InitEv:
  867|      1|  std::string* Init() const { return nullptr; }
_ZN6google8protobuf8internal15AllocateAtLeastEm:
  155|      8|inline SizedPtr AllocateAtLeast(size_t size) {
  156|       |#if !defined(NDEBUG) && defined(ABSL_HAVE_THREAD_LOCAL) && \
  157|       |    defined(__cpp_inline_variables)
  158|       |  if (allocate_at_least_hook != nullptr) {
  159|       |    return allocate_at_least_hook(size, allocate_at_least_hook_context);
  160|       |  }
  161|       |#endif  // !NDEBUG && ABSL_HAVE_THREAD_LOCAL && __cpp_inline_variables
  162|      8|  return {Allocate(size), size};
  163|      8|}
_ZN6google8protobuf8internal11SizedDeleteEPvm:
  165|      7|inline void SizedDelete(void* p, size_t size) {
  166|      7|#if defined(__cpp_sized_deallocation)
  167|      7|  ::operator delete(p, size);
  168|       |#else
  169|       |  // Avoid -Wunused-parameter
  170|       |  (void)size;
  171|       |  ::operator delete(p);
  172|       |#endif
  173|      7|}
_ZN6google8protobuf8internal18PoisonMemoryRegionEPKvm:
  639|  1.20k|                               [[maybe_unused]] size_t n) {
  640|       |#if defined(ABSL_HAVE_ADDRESS_SANITIZER)
  641|       |  ASAN_POISON_MEMORY_REGION(p, n);
  642|       |#else
  643|       |  // Nothing
  644|  1.20k|#endif
  645|  1.20k|}
_ZN6google8protobuf8internal20UnpoisonMemoryRegionEPKvm:
  648|  1.80k|                                 [[maybe_unused]] size_t n) {
  649|       |#if defined(ABSL_HAVE_ADDRESS_SANITIZER)
  650|       |  static const bool kReallyHasMemoryPoisoning = [] {
  651|       |    // Test if poisoning is on. `allow_user_poisoning=0` would disable it.
  652|       |    // There is no official API for this, so we just probe.
  653|       |    alignas(8) char buf[8];
  654|       |    ASAN_POISON_MEMORY_REGION(buf, sizeof(buf));
  655|       |    bool res = __asan_address_is_poisoned(buf);
  656|       |    ASAN_UNPOISON_MEMORY_REGION(buf, sizeof(buf));
  657|       |    return res;
  658|       |  }();
  659|       |  if (kReallyHasMemoryPoisoning) {
  660|       |    ASAN_UNPOISON_MEMORY_REGION(p, n);
  661|       |  } else {
  662|       |    // When in ASan but with memory poisoning off, we still want to clear
  663|       |    // container annotations from such memory.
  664|       |    // We annotate the whole block as usable.
  665|       |    ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(p, static_cast<const char*>(p) + n, p,
  666|       |                                       static_cast<const char*>(p) + n);
  667|       |  }
  668|       |#else
  669|       |  // Nothing
  670|  1.80k|#endif
  671|  1.80k|}
_ZN6google8protobuf8internal7LaunderINS0_11MessageLiteEEEPT_S5_:
  747|    300|constexpr T* Launder(T* p) {
  748|    300|#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606L
  749|    300|  return std::launder(p);
  750|       |#elif ABSL_HAVE_BUILTIN(__builtin_launder)
  751|       |  return __builtin_launder(p);
  752|       |#else
  753|       |  return p;
  754|       |#endif
  755|    300|}
_ZN6google8protobuf8internal13StrongPointerIPNS1_16DummyWeakDefaultETnT_XadL_ZNS1_18dummy_weak_defaultEEEEEvv:
   74|      1|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|      1|  asm(".reloc ., BFD_RELOC_NONE, %p0" ::"Ws"(ptr));
   78|      1|}

_ZN6google8protobuf8internal20CalculateReserveSizeIPvLi8EEEiii:
 1502|      8|inline int CalculateReserveSize(int capacity, int new_size) {
 1503|      8|  constexpr int lower_limit =
 1504|      8|      RepeatedFieldLowerClampLimit<T, kHeapRepHeaderSize>();
 1505|      8|  if (new_size < lower_limit) {
  ------------------
  |  Branch (1505:7): [True: 0, False: 8]
  ------------------
 1506|       |    // Clamp to smallest allowed size.
 1507|      0|    return lower_limit;
 1508|      0|  }
 1509|      8|  constexpr int kMaxSizeBeforeClamp =
 1510|      8|      (std::numeric_limits<int>::max() - kHeapRepHeaderSize) / 2;
 1511|      8|  if (ABSL_PREDICT_FALSE(capacity > kMaxSizeBeforeClamp)) {
  ------------------
  |  |  190|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 8]
  |  |  |  Branch (190:49): [Folded, False: 8]
  |  |  |  Branch (190:58): [True: 0, False: 8]
  |  |  ------------------
  ------------------
 1512|      0|    return std::numeric_limits<int>::max();
 1513|      0|  }
 1514|      8|  constexpr int kSooCapacityElements = SooCapacityElements<T>();
 1515|      8|  if (kSooCapacityElements > 0 && kSooCapacityElements < lower_limit) {
  ------------------
  |  Branch (1515:7): [True: 0, Folded]
  |  Branch (1515:35): [Folded, False: 0]
  ------------------
 1516|       |    // In this case, we need to set capacity to 0 here to ensure power-of-two
 1517|       |    // sized allocations.
 1518|      0|    if (capacity < lower_limit) capacity = 0;
  ------------------
  |  Branch (1518:9): [True: 0, False: 0]
  ------------------
 1519|      8|  } else {
 1520|     16|    ABSL_DCHECK(capacity == 0 || capacity >= lower_limit)
  ------------------
  |  |   47|      0|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      8|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      8|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|     16|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|     16|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 8, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      8|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 8]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      8|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 8, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      8|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      8|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1521|     16|        << capacity << " " << lower_limit;
 1522|      8|  }
 1523|       |  // We want to double the number of bytes, not the number of elements, to try
 1524|       |  // to stay within power-of-two allocations.
 1525|       |  // The allocation has kHeapRepHeaderSize + sizeof(T) * capacity.
 1526|      8|  int doubled_size = 2 * capacity + kHeapRepHeaderSize / sizeof(T);
 1527|      8|  return std::max(doubled_size, new_size);
 1528|      8|}

_ZN6google8protobuf8internal20RepeatedPtrFieldBase14InternalExtendEiPNS0_5ArenaE:
   46|      8|void** RepeatedPtrFieldBase::InternalExtend(int extend_amount, Arena* arena) {
   47|      8|  ABSL_DCHECK(extend_amount > 0);
  ------------------
  |  |   47|      8|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      8|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     16|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      8|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|     16|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|     16|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 8, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      8|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 8]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      8|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 8, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|     16|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|     16|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   48|      8|  ABSL_DCHECK_EQ(arena, GetArena());
  ------------------
  |  |   74|      8|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|      8|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      8|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 8]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      8|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   49|      8|  constexpr size_t kPtrSize = sizeof(rep()->elements[0]);
   50|      8|  constexpr size_t kMaxSize = std::numeric_limits<size_t>::max();
   51|      8|  constexpr size_t kMaxCapacity = (kMaxSize - kRepHeaderSize) / kPtrSize;
   52|      8|  const int old_capacity = Capacity();
   53|      8|  Rep* new_rep = nullptr;
   54|       |
   55|      8|  int new_capacity = internal::CalculateReserveSize<void*, kRepHeaderSize>(
   56|      8|      old_capacity, old_capacity + extend_amount);
   57|      8|  {
   58|      8|    ABSL_DCHECK_LE(new_capacity, kMaxCapacity)
  ------------------
  |  |   78|      0|  ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   91|      8|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      8|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 8]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      8|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   59|      0|        << "New capacity is too large to fit into internal representation";
   60|      8|    const size_t new_size = kRepHeaderSize + kPtrSize * new_capacity;
   61|      8|    if (arena == nullptr) {
  ------------------
  |  Branch (61:9): [True: 8, False: 0]
  ------------------
   62|      8|      const internal::SizedPtr alloc = internal::AllocateAtLeast(new_size);
   63|      8|      new_capacity = static_cast<int>((alloc.n - kRepHeaderSize) / kPtrSize);
   64|      8|      new_rep = reinterpret_cast<Rep*>(alloc.p);
   65|      8|    } else {
   66|      0|      auto* alloc = Arena::CreateArray<char>(arena, new_size);
   67|      0|      new_rep = reinterpret_cast<Rep*>(alloc);
   68|      0|    }
   69|      8|  }
   70|       |
   71|      8|  if (using_sso()) {
  ------------------
  |  Branch (71:7): [True: 1, False: 7]
  ------------------
   72|      1|    new_rep->capacity = new_capacity;
   73|      1|    new_rep->allocated_size = tagged_rep_or_elem_ != nullptr ? 1 : 0;
  ------------------
  |  Branch (73:31): [True: 1, False: 0]
  ------------------
   74|      1|    new_rep->elements[0] = tagged_rep_or_elem_;
   75|      7|  } else {
   76|      7|    Rep* old_rep = rep();
   77|      7|    new_rep->capacity = new_capacity;
   78|      7|    new_rep->allocated_size = old_rep->allocated_size;
   79|      7|    memcpy(new_rep->elements, old_rep->elements,
   80|      7|           new_rep->allocated_size * kPtrSize);
   81|      7|    size_t old_total_size = old_capacity * kPtrSize + kRepHeaderSize;
   82|      7|    if (arena == nullptr) {
  ------------------
  |  Branch (82:9): [True: 7, False: 0]
  ------------------
   83|      7|      internal::SizedDelete(old_rep, old_total_size);
   84|      7|    } else {
   85|      0|      arena->ReturnArrayMemory(old_rep, old_total_size);
   86|      0|    }
   87|      7|  }
   88|       |
   89|      8|  tagged_rep_or_elem_ =
   90|      8|      reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(new_rep) + 1);
   91|       |
   92|      8|  return &new_rep->elements[current_size_];
   93|      8|}

_ZN6google8protobuf8internal20RepeatedPtrFieldBase11AddInternalEPNS0_5ArenaEN4absl12lts_2026081711FunctionRefIFvS4_RPvEEE:
  910|    298|    Arena* arena, absl::FunctionRef<ElementNewFn> factory) {
  911|    298|  ABSL_DCHECK_EQ(arena, GetArena());
  ------------------
  |  |   74|    298|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|    298|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    298|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 298]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    298|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  912|    298|  if (tagged_rep_or_elem_ == nullptr) {
  ------------------
  |  Branch (912:7): [True: 1, False: 297]
  ------------------
  913|      1|    ExchangeCurrentSize(1);
  914|      1|    factory(arena, tagged_rep_or_elem_);
  915|      1|    return tagged_rep_or_elem_;
  916|      1|  }
  917|    297|  absl::PrefetchToLocalCache(tagged_rep_or_elem_);
  918|    297|  if (using_sso()) {
  ------------------
  |  Branch (918:7): [True: 1, False: 296]
  ------------------
  919|      1|    if (current_size_ == 0) {
  ------------------
  |  Branch (919:9): [True: 0, False: 1]
  ------------------
  920|      0|      ExchangeCurrentSize(1);
  921|      0|      return tagged_rep_or_elem_;
  922|      0|    }
  923|      1|    void*& result = *InternalExtend(1, arena);
  924|      1|    factory(arena, result);
  925|      1|    Rep* r = rep();
  926|      1|    r->allocated_size = 2;
  927|      1|    ExchangeCurrentSize(2);
  928|      1|    return result;
  929|      1|  }
  930|    296|  Rep* r = rep();
  931|    296|  if (ABSL_PREDICT_FALSE(SizeAtCapacity())) {
  ------------------
  |  |  190|    296|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 7, False: 289]
  |  |  |  Branch (190:49): [Folded, False: 296]
  |  |  |  Branch (190:58): [True: 7, False: 289]
  |  |  ------------------
  ------------------
  932|      7|    InternalExtend(1, arena);
  933|      7|    r = rep();
  934|    289|  } else {
  935|    289|    if (ClearedCount() > 0) {
  ------------------
  |  Branch (935:9): [True: 0, False: 289]
  ------------------
  936|      0|      return r->elements[ExchangeCurrentSize(current_size_ + 1)];
  937|      0|    }
  938|    289|  }
  939|    296|  ++r->allocated_size;
  940|    296|  void*& result = r->elements[ExchangeCurrentSize(current_size_ + 1)];
  941|    296|  factory(arena, result);
  942|    296|  return result;
  943|    296|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase19ExchangeCurrentSizeEi:
  759|    298|  inline int ExchangeCurrentSize(int new_size) {
  760|    298|    return std::exchange(current_size_, new_size);
  761|    298|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase9using_ssoEv:
  806|  1.79k|  bool using_sso() const {
  807|  1.79k|    return (reinterpret_cast<uintptr_t>(tagged_rep_or_elem_) & 1) == 0;
  808|  1.79k|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase3repEv:
  797|  1.80k|  Rep* rep() {
  798|  1.80k|    ABSL_DCHECK(!using_sso());
  ------------------
  |  |   47|  1.80k|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|  1.80k|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  3.60k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|  1.80k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|  3.60k|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|  3.60k|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1.80k, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|  1.80k|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1.80k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|  1.80k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 1.80k, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|  3.60k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|  3.60k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  799|  1.80k|    return reinterpret_cast<Rep*>(
  800|  1.80k|        reinterpret_cast<uintptr_t>(tagged_rep_or_elem_) - 1);
  801|  1.80k|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase14SizeAtCapacityEv:
  762|    296|  inline bool SizeAtCapacity() const {
  763|       |    // Harden invariant size() <= allocated_size() <= Capacity().
  764|    296|    ABSL_DCHECK_LE(size(), allocated_size());
  ------------------
  |  |   78|    296|  ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   91|    296|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    296|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 296]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    296|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  765|    296|    ABSL_DCHECK_LE(allocated_size(), Capacity());
  ------------------
  |  |   78|    296|  ABSL_LOG_INTERNAL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   91|    296|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    296|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 296]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    296|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  766|    296|    return current_size_ == Capacity();
  767|    296|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8CapacityEv:
  238|    304|  int Capacity() const {
  239|    304|    int res = using_sso() ? kSSOCapacity : rep()->capacity;
  ------------------
  |  Branch (239:15): [True: 1, False: 303]
  ------------------
  240|    304|    PROTOBUF_ASSUME(res >= 0);
  ------------------
  |  |  733|    304|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  241|    304|    return res;
  242|    304|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3repEv:
  802|    594|  const Rep* rep() const {
  803|    594|    return const_cast<RepeatedPtrFieldBase*>(this)->rep();
  804|    594|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase12ClearedCountEv:
  642|    289|  int ClearedCount() const { return allocated_size() - current_size_; }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase14allocated_sizeEv:
  793|    289|  int allocated_size() const {
  794|    289|    return using_sso() ? (tagged_rep_or_elem_ != nullptr ? 1 : 0)
  ------------------
  |  Branch (794:12): [True: 0, False: 289]
  |  Branch (794:27): [True: 0, False: 0]
  ------------------
  795|    289|                       : rep()->allocated_size;
  796|    289|  }
_ZN6google8protobuf8internal21RuntimeAssertInBoundsEii:
  130|    898|PROTOBUF_EXPORT inline void RuntimeAssertInBounds(int index, int size) {
  131|       |  if constexpr (GetBoundsCheckMode() == BoundsCheckMode::kAbort) {
  132|       |    if (ABSL_PREDICT_FALSE(index < 0 || index >= size)) {
  133|       |      // "No merge" attribute used to improve debuggability by telling the
  134|       |      // compiler not to merge these failure paths. Note that this is currently
  135|       |      // best-effort in clang/llvm.
  136|       |      PROTOBUF_NO_MERGE LogIndexOutOfBoundsAndAbort(index, size);
  137|       |    }
  138|       |  }
  139|    898|  ABSL_DCHECK_GE(index, 0);
  ------------------
  |  |   82|    898|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|    898|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    898|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 898]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    898|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  140|    898|  ABSL_DCHECK_LT(index, size);
  ------------------
  |  |   80|    898|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|    898|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    898|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 898]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    898|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  141|    898|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv:
  227|  1.49k|  int size() const {
  228|  1.49k|    int res = current_size_;
  229|  1.49k|    PROTOBUF_ASSUME(res >= 0);
  ------------------
  |  |  733|  1.49k|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  230|  1.49k|    return res;
  231|  1.49k|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase10element_atEi:
  782|    898|  void*& element_at(int index) {
  783|    898|    if (using_sso()) {
  ------------------
  |  Branch (783:9): [True: 0, False: 898]
  ------------------
  784|      0|      ABSL_DCHECK_EQ(index, 0);
  ------------------
  |  |   74|      0|  ABSL_LOG_INTERNAL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   87|      0|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 0]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  785|      0|      return tagged_rep_or_elem_;
  786|      0|    }
  787|    898|    return rep()->elements[index];
  788|    898|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase10element_atEi:
  789|    898|  const void* element_at(int index) const {
  790|    898|    return const_cast<RepeatedPtrFieldBase*>(this)->element_at(index);
  791|    898|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS1_18GenericTypeHandlerINS0_11MessageLiteEEEEEPNT_4TypeEPv:
  811|    298|  static inline Value<TypeHandler>* cast(void* element) {
  812|    298|    return reinterpret_cast<Value<TypeHandler>*>(element);
  813|    298|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8raw_dataEv:
  489|      2|  void* const* raw_data() const { return elements(); }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8elementsEv:
  775|      2|  void* const* elements() const {
  776|      2|    return using_sso() ? &tagged_rep_or_elem_ : +rep()->elements;
  ------------------
  |  Branch (776:12): [True: 0, False: 2]
  ------------------
  777|      2|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2ENS1_22InternalMetadataOffsetE:
  211|      1|      : tagged_rep_or_elem_(nullptr), current_size_(0), resolver_(offset) {}
_ZN6google8protobuf8internal18GenericTypeHandlerINS0_11MessageLiteEE23GetNewFromPrototypeFuncEPKS3_:
 1082|    298|  static constexpr auto GetNewFromPrototypeFunc(const Type* prototype) {
 1083|    298|    static_assert(std::is_base_of_v<MessageLite, Type>);
 1084|    298|    ABSL_DCHECK(prototype != nullptr);
  ------------------
  |  |   47|    298|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|    298|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|    596|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|    298|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|    596|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|    596|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 298, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|    298|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 298]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|    298|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 298, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|    596|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|    596|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1085|    298|    return
 1086|    298|        [prototype](Arena* arena, void*& ptr) { ptr = prototype->New(arena); };
 1087|    298|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase16AddFromPrototypeINS1_18GenericTypeHandlerINS0_11MessageLiteEEEEEPNT_4TypeEPNS0_5ArenaEPKS8_:
  376|    298|      Arena* arena, const Value<TypeHandler>* prototype) {
  377|    298|    using H = CommonHandler<TypeHandler>;
  378|    298|    Value<TypeHandler>* result = cast<TypeHandler>(
  379|    298|        AddInternal(arena, H::GetNewFromPrototypeFunc(prototype)));
  380|    298|    return result;
  381|    298|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE4sizeEv:
 1740|    600|inline int RepeatedPtrField<Element>::size() const {
 1741|    600|  return RepeatedPtrFieldBase::size();
 1742|    600|}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3GetEi:
 1746|    898|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1747|    898|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 1748|    898|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS1_18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEEEEERKNT_4TypeEi:
  354|    898|  PROTOBUF_FUTURE_ADD_NODISCARD const Value<TypeHandler>& Get(int index) const {
  355|       |    if constexpr (GetBoundsCheckMode() == BoundsCheckMode::kReturnDefault) {
  356|       |      if (ABSL_PREDICT_FALSE(index < 0 || index >= size())) {
  357|       |        // `default_instance()` is not supported for MessageLite and Message.
  358|       |        if constexpr (TypeHandler::has_default_instance()) {
  359|       |          LogIndexOutOfBounds(index, current_size_);
  360|       |          return TypeHandler::default_instance();
  361|       |        }
  362|       |      }
  363|       |    }
  364|       |    // We refactor this to a separate function instead of inlining it so we
  365|       |    // can measure the performance impact more easily.
  366|    898|    RuntimeAssertInBounds(index, size());
  367|    898|    return *cast<TypeHandler>(element_at(index));
  368|    898|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS1_18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEEEEEPKNT_4TypeEPKv:
  815|    898|  static inline const Value<TypeHandler>* cast(const void* element) {
  816|    898|    return reinterpret_cast<const Value<TypeHandler>*>(element);
  817|    898|  }
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEEC2ENS0_8internal18InternalVisibilityENS5_22InternalMetadataOffsetE:
 1236|      1|      : RepeatedPtrField(offset) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEEC2ENS0_8internal22InternalMetadataOffsetE:
 1627|      1|    : RepeatedPtrFieldBase(offset) {
 1628|       |  // We can't have StaticValidityCheck here because that requires Element to be
 1629|       |  // a complete type, and in split repeated fields cases, we call
 1630|       |  // CreateMessage<RepeatedPtrField<T>> for incomplete Ts.
 1631|      1|}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE5beginEv:
 2409|      1|RepeatedPtrField<Element>::begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2410|      1|  return iterator(raw_data());
 2411|      1|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN13sentencepiece24ModelProto_SentencePieceEEC2EPKPv:
 2169|      2|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEC2IS4_vEERKNS2_IT_EE:
 2177|      2|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3endEv:
 2424|      1|RepeatedPtrField<Element>::end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2425|      1|  return iterator(raw_data() + size());
 2426|      1|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEES8_:
 2203|    299|  friend bool operator!=(const iterator& x, const iterator& y) {
 2204|    299|    return x.it_ != y.it_;
 2205|    299|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEppEv:
 2188|    298|  iterator& operator++() {
 2189|    298|    ++it_;
 2190|    298|    return *this;
 2191|    298|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEdeEv:
 2180|    298|  PROTOBUF_FUTURE_ADD_NODISCARD reference operator*() const {
 2181|    298|    return *reinterpret_cast<Element*>(*it_);
 2182|    298|  }
_ZZN6google8protobuf8internal18GenericTypeHandlerINS0_11MessageLiteEE23GetNewFromPrototypeFuncEPKS3_ENKUlPNS0_5ArenaERPvE_clES8_SA_:
 1086|    298|        [prototype](Arena* arena, void*& ptr) { ptr = prototype->New(arena); };

_ZN6google8protobuf8internal19ShiftMixParseVarintIjLi10EEEPKcS4_Rl:
   55|      1|ShiftMixParseVarint(const char* p, int64_t& res1) {
   56|      1|  using Signed = std::make_signed_t<VarintType>;
   57|      1|  constexpr bool kIs64BitVarint = std::is_same_v<Signed, int64_t>;
   58|      1|  constexpr bool kIs32BitVarint = std::is_same_v<Signed, int32_t>;
   59|      1|  static_assert(kIs64BitVarint || kIs32BitVarint, "");
   60|       |
   61|       |  // The algorithm relies on sign extension for each byte to set all high bits
   62|       |  // when the varint continues. It also relies on asserting all of the lower
   63|       |  // bits for each successive byte read. This allows the result to be aggregated
   64|       |  // using a bitwise AND. For example:
   65|       |  //
   66|       |  //          8       1          64     57 ... 24     17  16      9  8       1
   67|       |  // ptr[0] = 1aaa aaaa ; res1 = 1111 1111 ... 1111 1111  1111 1111  1aaa aaaa
   68|       |  // ptr[1] = 1bbb bbbb ; res2 = 1111 1111 ... 1111 1111  11bb bbbb  b111 1111
   69|       |  // ptr[2] = 0ccc cccc ; res3 = 0000 0000 ... 000c cccc  cc11 1111  1111 1111
   70|       |  //                             ---------------------------------------------
   71|       |  //        res1 & res2 & res3 = 0000 0000 ... 000c cccc  ccbb bbbb  baaa aaaa
   72|       |  //
   73|       |  // On x86-64, a shld from a single register filled with enough 1s in the high
   74|       |  // bits can accomplish all this in one instruction. It so happens that res1
   75|       |  // has 57 high bits of ones, which is enough for the largest shift done.
   76|       |  //
   77|       |  // Just as importantly, by keeping results in res1, res2, and res3, we take
   78|       |  // advantage of the superscalar abilities of the CPU.
   79|      1|  const auto next = [&p] { return static_cast<const int8_t>(*p++); };
   80|      1|  const auto last = [&p] { return static_cast<const int8_t>(p[-1]); };
   81|       |
   82|      1|  int64_t res2, res3;  // accumulated result chunks
   83|      1|  res1 = next();
   84|      1|  if (ABSL_PREDICT_TRUE(res1 >= 0)) return p;
  ------------------
  |  |  191|      1|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 1]
  |  |  |  Branch (191:57): [True: 1, False: 0]
  |  |  ------------------
  ------------------
   85|      0|  if (limit <= 1) goto limit0;
  ------------------
  |  Branch (85:7): [Folded, False: 0]
  ------------------
   86|       |
   87|       |  // Densify all ops with explicit FALSE predictions from here on, except that
   88|       |  // we predict length = 5 as a common length for fields like timestamp.
   89|      0|  if (ABSL_PREDICT_FALSE(VarintShl<1>(next(), res1, res2))) goto done1;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   90|      0|  if (limit <= 2) goto limit1;
  ------------------
  |  Branch (90:7): [Folded, False: 0]
  ------------------
   91|      0|  if (ABSL_PREDICT_FALSE(VarintShl<2>(next(), res1, res3))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   92|      0|  if (limit <= 3) goto limit2;
  ------------------
  |  Branch (92:7): [Folded, False: 0]
  ------------------
   93|      0|  if (ABSL_PREDICT_FALSE(VarintShlAnd<3>(next(), res1, res2))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   94|      0|  if (limit <= 4) goto limit2;
  ------------------
  |  Branch (94:7): [Folded, False: 0]
  ------------------
   95|      0|  if (ABSL_PREDICT_TRUE(VarintShlAnd<4>(next(), res1, res3))) goto done2;
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   96|      0|  if (limit <= 5) goto limit2;
  ------------------
  |  Branch (96:7): [Folded, False: 0]
  ------------------
   97|       |
   98|      0|  if (kIs64BitVarint) {
  ------------------
  |  Branch (98:7): [Folded, False: 0]
  ------------------
   99|      0|    if (ABSL_PREDICT_FALSE(VarintShlAnd<5>(next(), res1, res2))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  100|      0|    if (limit <= 6) goto limit2;
  ------------------
  |  Branch (100:9): [Folded, False: 0]
  ------------------
  101|      0|    if (ABSL_PREDICT_FALSE(VarintShlAnd<6>(next(), res1, res3))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  102|      0|    if (limit <= 7) goto limit2;
  ------------------
  |  Branch (102:9): [Folded, False: 0]
  ------------------
  103|      0|    if (ABSL_PREDICT_FALSE(VarintShlAnd<7>(next(), res1, res2))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  104|      0|    if (limit <= 8) goto limit2;
  ------------------
  |  Branch (104:9): [Folded, False: 0]
  ------------------
  105|      0|    if (ABSL_PREDICT_FALSE(VarintShlAnd<8>(next(), res1, res3))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  106|      0|    if (limit <= 9) goto limit2;
  ------------------
  |  Branch (106:9): [Folded, False: 0]
  ------------------
  107|      0|  } else {
  108|       |    // An overlong int32 is expected to span the full 10 bytes
  109|      0|    if (ABSL_PREDICT_FALSE(!(next() & 0x80))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  110|      0|    if (limit <= 6) goto limit2;
  ------------------
  |  Branch (110:9): [Folded, False: 0]
  ------------------
  111|      0|    if (ABSL_PREDICT_FALSE(!(next() & 0x80))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  112|      0|    if (limit <= 7) goto limit2;
  ------------------
  |  Branch (112:9): [Folded, False: 0]
  ------------------
  113|      0|    if (ABSL_PREDICT_FALSE(!(next() & 0x80))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  114|      0|    if (limit <= 8) goto limit2;
  ------------------
  |  Branch (114:9): [Folded, False: 0]
  ------------------
  115|      0|    if (ABSL_PREDICT_FALSE(!(next() & 0x80))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  116|      0|    if (limit <= 9) goto limit2;
  ------------------
  |  Branch (116:9): [Folded, False: 0]
  ------------------
  117|      0|  }
  118|       |
  119|       |  // For valid 64bit varints, the 10th byte/ptr[9] should be exactly 1. In this
  120|       |  // case, the continuation bit of ptr[8] already set the top bit of res3
  121|       |  // correctly, so all we have to do is check that the expected case is true.
  122|      0|  if (ABSL_PREDICT_TRUE(next() == 1)) goto done2;
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  123|       |
  124|      0|  if (ABSL_PREDICT_FALSE(last() & 0x80)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  125|       |    // If the continue bit is set, it is an unterminated varint.
  126|      0|    return nullptr;
  127|      0|  }
  128|       |
  129|       |  // A zero value of the first bit of the 10th byte represents an
  130|       |  // over-serialized varint. This case should not happen, but if does (say, due
  131|       |  // to a nonconforming serializer), deassert the continuation bit that came
  132|       |  // from ptr[8].
  133|      0|  if (kIs64BitVarint && (last() & 1) == 0) {
  ------------------
  |  Branch (133:7): [Folded, False: 0]
  |  Branch (133:25): [True: 0, False: 0]
  ------------------
  134|      0|    static constexpr int bits = 64 - 1;
  135|      0|#if defined(__GCC_ASM_FLAG_OUTPUTS__) && defined(__x86_64__)
  136|       |    // Use a small instruction since this is an uncommon code path.
  137|      0|    asm("btc %[bits], %[res3]" : [res3] "+r"(res3) : [bits] "i"(bits));
  138|       |#else
  139|       |    res3 ^= int64_t{1} << bits;
  140|       |#endif
  141|      0|  }
  142|       |
  143|      0|done2:
  144|      0|  res2 &= res3;
  145|      0|done1:
  146|      0|  res1 &= res2;
  147|      0|  PROTOBUF_ASSUME(p != nullptr);
  ------------------
  |  |  733|      0|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  148|      0|  return p;
  149|      0|limit2:
  150|      0|  res2 &= res3;
  151|      0|limit1:
  152|      0|  res1 &= res2;
  153|      0|limit0:
  154|      0|  PROTOBUF_ASSUME(p != nullptr);
  ------------------
  |  |  733|      0|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  155|      0|  PROTOBUF_ASSUME(res1 < 0);
  ------------------
  |  |  733|      0|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  156|      0|  return p;
  157|      0|}
_ZZN6google8protobuf8internal19ShiftMixParseVarintIjLi10EEEPKcS4_RlENKUlvE_clEv:
   79|      1|  const auto next = [&p] { return static_cast<const int8_t>(*p++); };
_ZN6google8protobuf8internal19ShiftMixParseVarintImLi10EEEPKcS4_Rl:
   55|      1|ShiftMixParseVarint(const char* p, int64_t& res1) {
   56|      1|  using Signed = std::make_signed_t<VarintType>;
   57|      1|  constexpr bool kIs64BitVarint = std::is_same_v<Signed, int64_t>;
   58|      1|  constexpr bool kIs32BitVarint = std::is_same_v<Signed, int32_t>;
   59|      1|  static_assert(kIs64BitVarint || kIs32BitVarint, "");
   60|       |
   61|       |  // The algorithm relies on sign extension for each byte to set all high bits
   62|       |  // when the varint continues. It also relies on asserting all of the lower
   63|       |  // bits for each successive byte read. This allows the result to be aggregated
   64|       |  // using a bitwise AND. For example:
   65|       |  //
   66|       |  //          8       1          64     57 ... 24     17  16      9  8       1
   67|       |  // ptr[0] = 1aaa aaaa ; res1 = 1111 1111 ... 1111 1111  1111 1111  1aaa aaaa
   68|       |  // ptr[1] = 1bbb bbbb ; res2 = 1111 1111 ... 1111 1111  11bb bbbb  b111 1111
   69|       |  // ptr[2] = 0ccc cccc ; res3 = 0000 0000 ... 000c cccc  cc11 1111  1111 1111
   70|       |  //                             ---------------------------------------------
   71|       |  //        res1 & res2 & res3 = 0000 0000 ... 000c cccc  ccbb bbbb  baaa aaaa
   72|       |  //
   73|       |  // On x86-64, a shld from a single register filled with enough 1s in the high
   74|       |  // bits can accomplish all this in one instruction. It so happens that res1
   75|       |  // has 57 high bits of ones, which is enough for the largest shift done.
   76|       |  //
   77|       |  // Just as importantly, by keeping results in res1, res2, and res3, we take
   78|       |  // advantage of the superscalar abilities of the CPU.
   79|      1|  const auto next = [&p] { return static_cast<const int8_t>(*p++); };
   80|      1|  const auto last = [&p] { return static_cast<const int8_t>(p[-1]); };
   81|       |
   82|      1|  int64_t res2, res3;  // accumulated result chunks
   83|      1|  res1 = next();
   84|      1|  if (ABSL_PREDICT_TRUE(res1 >= 0)) return p;
  ------------------
  |  |  191|      1|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 1]
  |  |  |  Branch (191:57): [True: 1, False: 0]
  |  |  ------------------
  ------------------
   85|      0|  if (limit <= 1) goto limit0;
  ------------------
  |  Branch (85:7): [Folded, False: 0]
  ------------------
   86|       |
   87|       |  // Densify all ops with explicit FALSE predictions from here on, except that
   88|       |  // we predict length = 5 as a common length for fields like timestamp.
   89|      0|  if (ABSL_PREDICT_FALSE(VarintShl<1>(next(), res1, res2))) goto done1;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   90|      0|  if (limit <= 2) goto limit1;
  ------------------
  |  Branch (90:7): [Folded, False: 0]
  ------------------
   91|      0|  if (ABSL_PREDICT_FALSE(VarintShl<2>(next(), res1, res3))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   92|      0|  if (limit <= 3) goto limit2;
  ------------------
  |  Branch (92:7): [Folded, False: 0]
  ------------------
   93|      0|  if (ABSL_PREDICT_FALSE(VarintShlAnd<3>(next(), res1, res2))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   94|      0|  if (limit <= 4) goto limit2;
  ------------------
  |  Branch (94:7): [Folded, False: 0]
  ------------------
   95|      0|  if (ABSL_PREDICT_TRUE(VarintShlAnd<4>(next(), res1, res3))) goto done2;
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   96|      0|  if (limit <= 5) goto limit2;
  ------------------
  |  Branch (96:7): [Folded, False: 0]
  ------------------
   97|       |
   98|      0|  if (kIs64BitVarint) {
  ------------------
  |  Branch (98:7): [True: 0, Folded]
  ------------------
   99|      0|    if (ABSL_PREDICT_FALSE(VarintShlAnd<5>(next(), res1, res2))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  100|      0|    if (limit <= 6) goto limit2;
  ------------------
  |  Branch (100:9): [Folded, False: 0]
  ------------------
  101|      0|    if (ABSL_PREDICT_FALSE(VarintShlAnd<6>(next(), res1, res3))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  102|      0|    if (limit <= 7) goto limit2;
  ------------------
  |  Branch (102:9): [Folded, False: 0]
  ------------------
  103|      0|    if (ABSL_PREDICT_FALSE(VarintShlAnd<7>(next(), res1, res2))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  104|      0|    if (limit <= 8) goto limit2;
  ------------------
  |  Branch (104:9): [Folded, False: 0]
  ------------------
  105|      0|    if (ABSL_PREDICT_FALSE(VarintShlAnd<8>(next(), res1, res3))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  106|      0|    if (limit <= 9) goto limit2;
  ------------------
  |  Branch (106:9): [Folded, False: 0]
  ------------------
  107|      0|  } else {
  108|       |    // An overlong int32 is expected to span the full 10 bytes
  109|      0|    if (ABSL_PREDICT_FALSE(!(next() & 0x80))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  110|      0|    if (limit <= 6) goto limit2;
  ------------------
  |  Branch (110:9): [Folded, False: 0]
  ------------------
  111|      0|    if (ABSL_PREDICT_FALSE(!(next() & 0x80))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  112|      0|    if (limit <= 7) goto limit2;
  ------------------
  |  Branch (112:9): [Folded, False: 0]
  ------------------
  113|      0|    if (ABSL_PREDICT_FALSE(!(next() & 0x80))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  114|      0|    if (limit <= 8) goto limit2;
  ------------------
  |  Branch (114:9): [Folded, False: 0]
  ------------------
  115|      0|    if (ABSL_PREDICT_FALSE(!(next() & 0x80))) goto done2;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  116|      0|    if (limit <= 9) goto limit2;
  ------------------
  |  Branch (116:9): [Folded, False: 0]
  ------------------
  117|      0|  }
  118|       |
  119|       |  // For valid 64bit varints, the 10th byte/ptr[9] should be exactly 1. In this
  120|       |  // case, the continuation bit of ptr[8] already set the top bit of res3
  121|       |  // correctly, so all we have to do is check that the expected case is true.
  122|      0|  if (ABSL_PREDICT_TRUE(next() == 1)) goto done2;
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  123|       |
  124|      0|  if (ABSL_PREDICT_FALSE(last() & 0x80)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  125|       |    // If the continue bit is set, it is an unterminated varint.
  126|      0|    return nullptr;
  127|      0|  }
  128|       |
  129|       |  // A zero value of the first bit of the 10th byte represents an
  130|       |  // over-serialized varint. This case should not happen, but if does (say, due
  131|       |  // to a nonconforming serializer), deassert the continuation bit that came
  132|       |  // from ptr[8].
  133|      0|  if (kIs64BitVarint && (last() & 1) == 0) {
  ------------------
  |  Branch (133:7): [True: 0, Folded]
  |  Branch (133:25): [True: 0, False: 0]
  ------------------
  134|      0|    static constexpr int bits = 64 - 1;
  135|      0|#if defined(__GCC_ASM_FLAG_OUTPUTS__) && defined(__x86_64__)
  136|       |    // Use a small instruction since this is an uncommon code path.
  137|      0|    asm("btc %[bits], %[res3]" : [res3] "+r"(res3) : [bits] "i"(bits));
  138|       |#else
  139|       |    res3 ^= int64_t{1} << bits;
  140|       |#endif
  141|      0|  }
  142|       |
  143|      0|done2:
  144|      0|  res2 &= res3;
  145|      0|done1:
  146|      0|  res1 &= res2;
  147|      0|  PROTOBUF_ASSUME(p != nullptr);
  ------------------
  |  |  733|      0|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  148|      0|  return p;
  149|      0|limit2:
  150|      0|  res2 &= res3;
  151|      0|limit1:
  152|      0|  res1 &= res2;
  153|      0|limit0:
  154|      0|  PROTOBUF_ASSUME(p != nullptr);
  ------------------
  |  |  733|      0|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  155|      0|  PROTOBUF_ASSUME(res1 < 0);
  ------------------
  |  |  733|      0|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  156|      0|  return p;
  157|      0|}
_ZZN6google8protobuf8internal19ShiftMixParseVarintImLi10EEEPKcS4_RlENKUlvE_clEv:
   79|      1|  const auto next = [&p] { return static_cast<const int8_t>(*p++); };

_ZNK4absl12lts_202608176Status2okEv:
 1010|     29|inline bool Status::ok() const {
 1011|     29|  return rep_ == CodeToInlinedRep(absl::StatusCode::kOk);
 1012|     29|}
_ZN4absl12lts_202608176Status16CodeToInlinedRepENS0_10StatusCodeE:
 1093|     60|constexpr uintptr_t Status::CodeToInlinedRep(absl::StatusCode code) {
 1094|     60|  return (static_cast<uintptr_t>(code) << 2) + 1;
 1095|     60|}
_ZN4absl12lts_202608176StatusD2Ev:
 1008|     29|inline Status::~Status() { Unref(rep_); }
_ZN4absl12lts_202608176Status5UnrefEm:
 1121|     29|inline void Status::Unref(uintptr_t rep) {
 1122|     29|  if (!IsInlined(rep)) RepToPointer(rep)->Unref();
  ------------------
  |  Branch (1122:7): [True: 0, False: 29]
  ------------------
 1123|     29|}
_ZN4absl12lts_202608176Status9IsInlinedEm:
 1089|     48|constexpr bool Status::IsInlined(uintptr_t rep) { return (rep & 1) != 0; }

_ZN13sentencepiece11TrainerSpec17IsInitializedImplERKN6google8protobuf11MessageLiteE:
 2019|      1|    const MessageLite& msg) {
 2020|      1|  auto& this_ = static_cast<const TrainerSpec&>(msg);
 2021|      1|  if (!this_._impl_._extensions_.IsInitialized(this_.GetArena(),
  ------------------
  |  Branch (2021:7): [True: 0, False: 1]
  ------------------
 2022|      1|                                        &default_instance())) {
 2023|      0|    return false;
 2024|      0|  }
 2025|      1|  return true;
 2026|      1|}
_ZN13sentencepiece14NormalizerSpec17IsInitializedImplERKN6google8protobuf11MessageLiteE:
 2351|      1|    const MessageLite& msg) {
 2352|      1|  auto& this_ = static_cast<const NormalizerSpec&>(msg);
 2353|      1|  if (!this_._impl_._extensions_.IsInitialized(this_.GetArena(),
  ------------------
  |  Branch (2353:7): [True: 0, False: 1]
  ------------------
 2354|      1|                                        &default_instance())) {
 2355|      0|    return false;
 2356|      0|  }
 2357|      1|  return true;
 2358|      1|}
_ZNK13sentencepiece24ModelProto_SentencePiece12GetClassDataEv:
 2458|    298|ModelProto_SentencePiece::GetClassData() const {
 2459|    298|  return ModelProto_SentencePiece_class_data_.base();
 2460|    298|}
_ZN13sentencepiece24ModelProto_SentencePiece17IsInitializedImplERKN6google8protobuf11MessageLiteE:
 2618|    298|    const MessageLite& msg) {
 2619|    298|  auto& this_ = static_cast<const ModelProto_SentencePiece&>(msg);
 2620|    298|  if (!this_._impl_._extensions_.IsInitialized(this_.GetArena(),
  ------------------
  |  Branch (2620:7): [True: 0, False: 298]
  ------------------
 2621|    298|                                        &default_instance())) {
 2622|      0|    return false;
 2623|      0|  }
 2624|    298|  return true;
 2625|    298|}
_ZN13sentencepiece10ModelProtoC2EPN6google8protobuf5ArenaE:
 2649|      1|    : Super_(arena) {
 2650|      1|#endif  // PROTOBUF_CUSTOM_VTABLE
 2651|      1|  SharedCtor(arena);
 2652|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.ModelProto)
 2653|      1|}
_ZNK13sentencepiece10ModelProto12GetClassDataEv:
 2742|      2|ModelProto::GetClassData() const {
 2743|      2|  return ModelProto_class_data_.base();
 2744|      2|}
_ZN13sentencepiece10ModelProto5ClearEv:
 2757|      1|PROTOBUF_NOINLINE void ModelProto::Clear() {
 2758|      1|  auto& this_ [[maybe_unused]] = *this;
 2759|       |  // @@protoc_insertion_point(message_clear_start:sentencepiece.ModelProto)
 2760|      1|  ::google::protobuf::internal::TSanWrite(&_impl_);
 2761|      1|  ::uint32_t cached_has_bits [[maybe_unused]] = 0;
 2762|       |
 2763|      1|  _impl_._extensions_.Clear();
 2764|      1|  cached_has_bits = this_._impl_._has_bits_[0];
 2765|      1|  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
  ------------------
  |  Branch (2765:7): [True: 0, False: 1]
  ------------------
 2766|      0|    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
  ------------------
  |  Branch (2766:9): [True: 0, False: 0]
  ------------------
 2767|      0|      _impl_.pieces_.Clear();
 2768|      0|    }
 2769|      0|    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
  ------------------
  |  Branch (2769:9): [True: 0, False: 0]
  ------------------
 2770|      0|      ABSL_DCHECK(this_._impl_.trainer_spec_ != nullptr);
  ------------------
  |  |   47|      0|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      0|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2771|      0|      this_._impl_.trainer_spec_->Clear();
 2772|      0|    }
 2773|      0|    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
  ------------------
  |  Branch (2773:9): [True: 0, False: 0]
  ------------------
 2774|      0|      ABSL_DCHECK(this_._impl_.normalizer_spec_ != nullptr);
  ------------------
  |  |   47|      0|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      0|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2775|      0|      this_._impl_.normalizer_spec_->Clear();
 2776|      0|    }
 2777|      0|    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
  ------------------
  |  Branch (2777:9): [True: 0, False: 0]
  ------------------
 2778|      0|      ABSL_DCHECK(this_._impl_.denormalizer_spec_ != nullptr);
  ------------------
  |  |   47|      0|  ABSL_LOG_INTERNAL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   44|      0|  ABSL_LOG_INTERNAL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2779|      0|      this_._impl_.denormalizer_spec_->Clear();
 2780|      0|    }
 2781|      0|  }
 2782|      1|  _impl_._has_bits_.Clear();
 2783|      1|  _internal_metadata_.Clear<::std::string>();
 2784|      1|}
_ZN13sentencepiece10ModelProto17IsInitializedImplERKN6google8protobuf11MessageLiteE:
 2956|      1|    const MessageLite& msg) {
 2957|      1|  auto& this_ = static_cast<const ModelProto&>(msg);
 2958|      1|  if (!this_._impl_._extensions_.IsInitialized(this_.GetArena(),
  ------------------
  |  Branch (2958:7): [True: 0, False: 1]
  ------------------
 2959|      1|                                        &default_instance())) {
 2960|      0|    return false;
 2961|      0|  }
 2962|      1|  if (!::google::protobuf::internal::AllAreInitialized(this_._internal_pieces()))
  ------------------
  |  Branch (2962:7): [True: 0, False: 1]
  ------------------
 2963|      0|    return false;
 2964|      1|  if (CheckHasBit(this_._impl_._has_bits_[0], 0x00000002U)) {
  ------------------
  |  Branch (2964:7): [True: 1, False: 0]
  ------------------
 2965|      1|    if (!this_._impl_.trainer_spec_->IsInitialized()) return false;
  ------------------
  |  Branch (2965:9): [True: 0, False: 1]
  ------------------
 2966|      1|  }
 2967|      1|  if (CheckHasBit(this_._impl_._has_bits_[0], 0x00000004U)) {
  ------------------
  |  Branch (2967:7): [True: 1, False: 0]
  ------------------
 2968|      1|    if (!this_._impl_.normalizer_spec_->IsInitialized()) return false;
  ------------------
  |  Branch (2968:9): [True: 0, False: 1]
  ------------------
 2969|      1|  }
 2970|      1|  if (CheckHasBit(this_._impl_._has_bits_[0], 0x00000008U)) {
  ------------------
  |  Branch (2970:7): [True: 0, False: 1]
  ------------------
 2971|      0|    if (!this_._impl_.denormalizer_spec_->IsInitialized()) return false;
  ------------------
  |  Branch (2971:9): [True: 0, False: 0]
  ------------------
 2972|      0|  }
 2973|      1|  return true;
 2974|      1|}
_ZN13sentencepiece10ModelProto10SharedCtorEPN6google8protobuf5ArenaE:
 2709|      1|inline void ModelProto::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
 2710|      1|  new (&_impl_) Impl_(internal_visibility(), arena);
 2711|      1|  ::memset(reinterpret_cast<char*>(&_impl_) +
 2712|      1|               offsetof(Impl_, trainer_spec_),
 2713|      1|           0,
 2714|      1|           offsetof(Impl_, denormalizer_spec_) -
 2715|       |               offsetof(Impl_, trainer_spec_) +
 2716|      1|               sizeof(Impl_::denormalizer_spec_));
 2717|      1|}
_ZN13sentencepiece10ModelProto5Impl_C2EN6google8protobuf8internal18InternalVisibilityEPNS3_5ArenaE:
 2701|      1|      : _extensions_ {}
 2702|       |        ,
 2703|      1|        pieces_ { visibility, ::_pbi::InternalMetadataOffset::Build<
 2704|      1|            ::sentencepiece::ModelProto,
 2705|      1|            PROTOBUF_FIELD_OFFSET(::sentencepiece::ModelProto, _impl_.pieces_)>()
 2706|      1|         }
 2707|      1|     {}

_ZNK13sentencepiece10ModelProto15normalizer_specEv:
 4818|      1|inline const ::sentencepiece::NormalizerSpec& ModelProto::normalizer_spec() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 4819|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.normalizer_spec)
 4820|      1|  return _internal_normalizer_spec();
 4821|      1|}
_ZNK13sentencepiece10ModelProto25_internal_normalizer_specEv:
 4813|      1|inline const ::sentencepiece::NormalizerSpec& ModelProto::_internal_normalizer_spec() const {
 4814|      1|  ::google::protobuf::internal::TSanRead(&_impl_);
 4815|      1|  const ::sentencepiece::NormalizerSpec* p = _impl_.normalizer_spec_;
 4816|      1|  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::sentencepiece::NormalizerSpec>(&::sentencepiece::NormalizerSpec_globals_);
  ------------------
  |  Branch (4816:10): [True: 1, False: 0]
  ------------------
 4817|      1|}
_ZNK13sentencepiece10ModelProto12trainer_specEv:
 4720|    267|inline const ::sentencepiece::TrainerSpec& ModelProto::trainer_spec() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 4721|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.trainer_spec)
 4722|    267|  return _internal_trainer_spec();
 4723|    267|}
_ZNK13sentencepiece10ModelProto22_internal_trainer_specEv:
 4715|    267|inline const ::sentencepiece::TrainerSpec& ModelProto::_internal_trainer_spec() const {
 4716|    267|  ::google::protobuf::internal::TSanRead(&_impl_);
 4717|    267|  const ::sentencepiece::TrainerSpec* p = _impl_.trainer_spec_;
 4718|    267|  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::sentencepiece::TrainerSpec>(&::sentencepiece::TrainerSpec_globals_);
  ------------------
  |  Branch (4718:10): [True: 267, False: 0]
  ------------------
 4719|    267|}
_ZNK13sentencepiece10ModelProto21has_denormalizer_specEv:
 4901|      1|inline bool ModelProto::has_denormalizer_spec() const {
 4902|      1|  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
 4903|      1|  PROTOBUF_ASSUME(!value || _impl_.denormalizer_spec_ != nullptr);
  ------------------
  |  |  733|      1|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  |  |  ------------------
  |  |  |  Branch (733:48): [True: 1, False: 0]
  |  |  |  Branch (733:48): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 4904|      1|  return value;
 4905|      1|}
_ZNK13sentencepiece14NormalizerSpec20precompiled_charsmapEv:
 4305|      1|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 4306|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.precompiled_charsmap)
 4307|      1|  return _internal_precompiled_charsmap();
 4308|      1|}
_ZNK13sentencepiece14NormalizerSpec30_internal_precompiled_charsmapEv:
 4323|      1|inline const ::std::string& NormalizerSpec::_internal_precompiled_charsmap() const {
 4324|      1|  ::google::protobuf::internal::TSanRead(&_impl_);
 4325|      1|  return _impl_.precompiled_charsmap_.Get();
 4326|      1|}
_ZN13sentencepiece10ModelProtoC2Ev:
 2087|      1|  inline ModelProto() : ModelProto(nullptr) {}
_ZN13sentencepiece11TrainerSpec16default_instanceEv:
  199|      1|  [[nodiscard]] static const TrainerSpec& default_instance() {
  200|      1|    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<TrainerSpec>(&TrainerSpec_globals_);
  201|      1|  }
_ZNK13sentencepiece11TrainerSpec13IsInitializedEv:
  232|      1|  [[nodiscard]] bool IsInitialized() const {
  233|      1|    return IsInitializedImpl(*this);
  234|      1|  }
_ZN13sentencepiece14NormalizerSpec16default_instanceEv:
 1225|      1|  [[nodiscard]] static const NormalizerSpec& default_instance() {
 1226|      1|    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<NormalizerSpec>(&NormalizerSpec_globals_);
 1227|      1|  }
_ZNK13sentencepiece14NormalizerSpec13IsInitializedEv:
 1258|      1|  [[nodiscard]] bool IsInitialized() const {
 1259|      1|    return IsInitializedImpl(*this);
 1260|      1|  }
_ZN13sentencepiece24ModelProto_SentencePiece16default_instanceEv:
 1690|    298|  [[nodiscard]] static const ModelProto_SentencePiece& default_instance() {
 1691|    298|    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ModelProto_SentencePiece>(&ModelProto_SentencePiece_globals_);
 1692|    298|  }
_ZNK13sentencepiece24ModelProto_SentencePiece13IsInitializedEv:
 1723|    298|  [[nodiscard]] bool IsInitialized() const {
 1724|    298|    return IsInitializedImpl(*this);
 1725|    298|  }
_ZN13sentencepiece10ModelProto16default_instanceEv:
 2127|      1|  [[nodiscard]] static const ModelProto& default_instance() {
 2128|      1|    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ModelProto>(&ModelProto_globals_);
 2129|      1|  }
_ZNK13sentencepiece11TrainerSpec10model_typeEv:
 2761|      1|inline ::sentencepiece::TrainerSpec_ModelType TrainerSpec::model_type() const {
 2762|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.model_type)
 2763|      1|  return _internal_model_type();
 2764|      1|}
_ZNK13sentencepiece11TrainerSpec20_internal_model_typeEv:
 2770|      1|inline ::sentencepiece::TrainerSpec_ModelType TrainerSpec::_internal_model_type() const {
 2771|      1|  ::google::protobuf::internal::TSanRead(&_impl_);
 2772|      1|  return static_cast<::sentencepiece::TrainerSpec_ModelType>(_impl_.model_type_);
 2773|      1|}
_ZNK13sentencepiece11TrainerSpec26treat_whitespace_as_suffixEv:
 3228|      1|inline bool TrainerSpec::treat_whitespace_as_suffix() const {
 3229|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.treat_whitespace_as_suffix)
 3230|      1|  return _internal_treat_whitespace_as_suffix();
 3231|      1|}
_ZNK13sentencepiece11TrainerSpec36_internal_treat_whitespace_as_suffixEv:
 3237|      1|inline bool TrainerSpec::_internal_treat_whitespace_as_suffix() const {
 3238|      1|  ::google::protobuf::internal::TSanRead(&_impl_);
 3239|      1|  return _impl_.treat_whitespace_as_suffix_;
 3240|      1|}
_ZNK13sentencepiece11TrainerSpec13byte_fallbackEv:
 3592|    257|inline bool TrainerSpec::byte_fallback() const {
 3593|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.byte_fallback)
 3594|    257|  return _internal_byte_fallback();
 3595|    257|}
_ZNK13sentencepiece11TrainerSpec23_internal_byte_fallbackEv:
 3601|    257|inline bool TrainerSpec::_internal_byte_fallback() const {
 3602|    257|  ::google::protobuf::internal::TSanRead(&_impl_);
 3603|    257|  return _impl_.byte_fallback_;
 3604|    257|}
_ZNK13sentencepiece11TrainerSpec9unk_pieceEv:
 3817|      2|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3818|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_piece)
 3819|      2|  if (_impl_.unk_piece_.IsDefault()) {
  ------------------
  |  Branch (3819:7): [True: 2, False: 0]
  ------------------
 3820|      2|    return Impl_::_i_give_permission_to_break_this_code_default_unk_piece_.get();
 3821|      2|  }
 3822|      0|  return _internal_unk_piece();
 3823|      2|}
_ZNK13sentencepiece11TrainerSpec9bos_pieceEv:
 3881|      2|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3882|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.bos_piece)
 3883|      2|  if (_impl_.bos_piece_.IsDefault()) {
  ------------------
  |  Branch (3883:7): [True: 2, False: 0]
  ------------------
 3884|      2|    return Impl_::_i_give_permission_to_break_this_code_default_bos_piece_.get();
 3885|      2|  }
 3886|      0|  return _internal_bos_piece();
 3887|      2|}
_ZNK13sentencepiece11TrainerSpec9eos_pieceEv:
 3945|      2|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3946|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.eos_piece)
 3947|      2|  if (_impl_.eos_piece_.IsDefault()) {
  ------------------
  |  Branch (3947:7): [True: 2, False: 0]
  ------------------
 3948|      2|    return Impl_::_i_give_permission_to_break_this_code_default_eos_piece_.get();
 3949|      2|  }
 3950|      0|  return _internal_eos_piece();
 3951|      2|}
_ZNK13sentencepiece11TrainerSpec9pad_pieceEv:
 4009|      2|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 4010|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.pad_piece)
 4011|      2|  if (_impl_.pad_piece_.IsDefault()) {
  ------------------
  |  Branch (4011:7): [True: 2, False: 0]
  ------------------
 4012|      2|    return Impl_::_i_give_permission_to_break_this_code_default_pad_piece_.get();
 4013|      2|  }
 4014|      0|  return _internal_pad_piece();
 4015|      2|}
_ZNK13sentencepiece24ModelProto_SentencePiece5pieceEv:
 4529|  1.44k|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 4530|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.piece)
 4531|  1.44k|  return _internal_piece();
 4532|  1.44k|}
_ZNK13sentencepiece24ModelProto_SentencePiece15_internal_pieceEv:
 4547|  1.44k|inline const ::std::string& ModelProto_SentencePiece::_internal_piece() const {
 4548|  1.44k|  ::google::protobuf::internal::TSanRead(&_impl_);
 4549|  1.44k|  return _impl_.piece_.Get();
 4550|  1.44k|}
_ZNK13sentencepiece24ModelProto_SentencePiece5scoreEv:
 4596|    635|inline float ModelProto_SentencePiece::score() const {
 4597|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.score)
 4598|    635|  return _internal_score();
 4599|    635|}
_ZNK13sentencepiece24ModelProto_SentencePiece15_internal_scoreEv:
 4605|    635|inline float ModelProto_SentencePiece::_internal_score() const {
 4606|    635|  ::google::protobuf::internal::TSanRead(&_impl_);
 4607|    635|  return _impl_.score_;
 4608|    635|}
_ZNK13sentencepiece24ModelProto_SentencePiece4typeEv:
 4624|  2.82k|inline ::sentencepiece::ModelProto_SentencePiece_Type ModelProto_SentencePiece::type() const {
 4625|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.type)
 4626|  2.82k|  return _internal_type();
 4627|  2.82k|}
_ZNK13sentencepiece24ModelProto_SentencePiece14_internal_typeEv:
 4633|  2.82k|inline ::sentencepiece::ModelProto_SentencePiece_Type ModelProto_SentencePiece::_internal_type() const {
 4634|  2.82k|  ::google::protobuf::internal::TSanRead(&_impl_);
 4635|  2.82k|  return static_cast<::sentencepiece::ModelProto_SentencePiece_Type>(_impl_.type_);
 4636|  2.82k|}
_ZNK13sentencepiece10ModelProto21_internal_pieces_sizeEv:
 4650|    598|inline int ModelProto::_internal_pieces_size() const {
 4651|    598|  return _internal_pieces().size();
 4652|    598|}
_ZNK13sentencepiece10ModelProto11pieces_sizeEv:
 4653|    598|inline int ModelProto::pieces_size() const {
 4654|    598|  return _internal_pieces_size();
 4655|    598|}
_ZNK13sentencepiece10ModelProto6piecesEi:
 4662|    600|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 4663|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.pieces)
 4664|    600|  return _internal_pieces().Get(index);
 4665|    600|}
_ZNK13sentencepiece10ModelProto6piecesEv:
 4682|      1|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 4683|       |  // @@protoc_insertion_point(field_list:sentencepiece.ModelProto.pieces)
 4684|      1|  return _internal_pieces();
 4685|      1|}
_ZNK13sentencepiece10ModelProto16_internal_piecesEv:
 4694|  1.20k|ModelProto::_internal_pieces() const {
 4695|  1.20k|  ::google::protobuf::internal::TSanRead(&_impl_);
 4696|  1.20k|  return _impl_.pieces_;
 4697|  1.20k|}

_ZN13sentencepiece12ModelFactory6CreateERKNS_10ModelProtoE:
   29|      1|    const ModelProto& model_proto) {
   30|      1|  const auto& trainer_spec = model_proto.trainer_spec();
   31|       |
   32|      1|  switch (trainer_spec.model_type()) {
   33|      1|    case TrainerSpec::UNIGRAM:
  ------------------
  |  Branch (33:5): [True: 1, False: 0]
  ------------------
   34|      1|      return std::make_unique<unigram::Model>(model_proto);
   35|      0|      break;
   36|      0|    case TrainerSpec::BPE:
  ------------------
  |  Branch (36:5): [True: 0, False: 1]
  ------------------
   37|      0|      return std::make_unique<bpe::Model>(model_proto);
   38|      0|      break;
   39|      0|    case TrainerSpec::WORD:
  ------------------
  |  Branch (39:5): [True: 0, False: 1]
  ------------------
   40|      0|      return std::make_unique<word::Model>(model_proto);
   41|      0|      break;
   42|      0|    case TrainerSpec::CHAR:
  ------------------
  |  Branch (42:5): [True: 0, False: 1]
  ------------------
   43|      0|      return std::make_unique<character::Model>(model_proto);
   44|      0|      break;
   45|      0|    default:
  ------------------
  |  Branch (45:5): [True: 0, False: 1]
  ------------------
   46|      0|      LOG(ERROR) << "Unknown model_type: " << trainer_spec.model_type();
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   47|      0|      return nullptr;
   48|      0|      break;
   49|      1|  }
   50|       |
   51|      0|  return std::make_unique<unigram::Model>(model_proto);
   52|      1|}

_ZNK13sentencepiece14ModelInterface9unk_pieceEv:
   49|      1|absl::string_view ModelInterface::unk_piece() const {
   50|      1|  RETURN_PIECE(unk_piece, "<unk>");
  ------------------
  |  |   46|      1|  if (model_proto_->trainer_spec().name().empty()) return default_value; \
  |  |  ------------------
  |  |  |  Branch (46:7): [True: 0, False: 1]
  |  |  ------------------
  |  |   47|      1|  return model_proto_->trainer_spec().name();
  ------------------
   51|      0|}
_ZNK13sentencepiece14ModelInterface9bos_pieceEv:
   53|      1|absl::string_view ModelInterface::bos_piece() const {
   54|      1|  RETURN_PIECE(bos_piece, "<s>");
  ------------------
  |  |   46|      1|  if (model_proto_->trainer_spec().name().empty()) return default_value; \
  |  |  ------------------
  |  |  |  Branch (46:7): [True: 0, False: 1]
  |  |  ------------------
  |  |   47|      1|  return model_proto_->trainer_spec().name();
  ------------------
   55|      0|}
_ZNK13sentencepiece14ModelInterface9eos_pieceEv:
   57|      1|absl::string_view ModelInterface::eos_piece() const {
   58|      1|  RETURN_PIECE(eos_piece, "</s>");
  ------------------
  |  |   46|      1|  if (model_proto_->trainer_spec().name().empty()) return default_value; \
  |  |  ------------------
  |  |  |  Branch (46:7): [True: 0, False: 1]
  |  |  ------------------
  |  |   47|      1|  return model_proto_->trainer_spec().name();
  ------------------
   59|      0|}
_ZNK13sentencepiece14ModelInterface9pad_pieceEv:
   61|      1|absl::string_view ModelInterface::pad_piece() const {
   62|      1|  RETURN_PIECE(pad_piece, "<pad>");
  ------------------
  |  |   46|      1|  if (model_proto_->trainer_spec().name().empty()) return default_value; \
  |  |  ------------------
  |  |  |  Branch (46:7): [True: 0, False: 1]
  |  |  ------------------
  |  |   47|      1|  return model_proto_->trainer_spec().name();
  ------------------
   63|      0|}
_ZN13sentencepiece14ModelInterface16InitializePiecesEb:
   81|      1|void ModelInterface::InitializePieces(bool use_reserved_id_map) {
   82|      1|  pieces_.clear();
   83|      1|  reserved_id_map_.clear();
   84|      1|  unk_id_ = -1;
   85|       |
   86|      1|  std::set<absl::string_view> user_defined_symbols;
   87|      1|  std::vector<bool> byte_found(256, false);
   88|       |
   89|      1|  int pieces_size = 0;
   90|      1|  int reserved_id_map_size = 0;
   91|    299|  for (int i = 0; i < model_proto_->pieces_size(); ++i) {
  ------------------
  |  Branch (91:19): [True: 298, False: 1]
  ------------------
   92|    298|    const auto& sp = model_proto_->pieces(i);
   93|    298|    static constexpr size_t kMaxPieceSize = 8000;
   94|    298|    if (sp.piece().size() >= kMaxPieceSize) {
  ------------------
  |  Branch (94:9): [True: 0, False: 298]
  ------------------
   95|      0|      status_ = absl::InternalError("piece is too long.");
   96|      0|      return;
   97|      0|    }
   98|    298|    const bool is_normal_piece =
   99|    298|        (sp.type() == ModelProto::SentencePiece::NORMAL ||
  ------------------
  |  Branch (99:10): [True: 39, False: 259]
  ------------------
  100|    259|         sp.type() == ModelProto::SentencePiece::USER_DEFINED ||
  ------------------
  |  Branch (100:10): [True: 0, False: 259]
  ------------------
  101|    259|         sp.type() == ModelProto::SentencePiece::UNUSED);
  ------------------
  |  Branch (101:10): [True: 0, False: 259]
  ------------------
  102|    298|    if (is_normal_piece || !use_reserved_id_map) {
  ------------------
  |  Branch (102:9): [True: 39, False: 259]
  |  Branch (102:28): [True: 0, False: 259]
  ------------------
  103|     39|      ++pieces_size;
  104|    259|    } else {
  105|    259|      ++reserved_id_map_size;
  106|    259|    }
  107|    298|  }
  108|      1|  pieces_.reserve(pieces_size);
  109|      1|  reserved_id_map_.reserve(reserved_id_map_size);
  110|       |
  111|    299|  for (int i = 0; i < model_proto_->pieces_size(); ++i) {
  ------------------
  |  Branch (111:19): [True: 298, False: 1]
  ------------------
  112|    298|    const auto& sp = model_proto_->pieces(i);
  113|    298|    if (sp.piece().empty()) {
  ------------------
  |  Branch (113:9): [True: 0, False: 298]
  ------------------
  114|      0|      status_ = absl::InternalError("piece must not be empty.");
  115|      0|      return;
  116|      0|    }
  117|    298|    if (sp.piece().find('\0') != absl::string_view::npos) {
  ------------------
  |  Branch (117:9): [True: 0, False: 298]
  ------------------
  118|      0|      status_ = absl::InternalError("piece must not include null character.");
  119|      0|      return;
  120|      0|    }
  121|    298|    if (use_reserved_id_map) {
  ------------------
  |  Branch (121:9): [True: 298, False: 0]
  ------------------
  122|    298|      const bool is_normal_piece =
  123|    298|          (sp.type() == ModelProto::SentencePiece::NORMAL ||
  ------------------
  |  Branch (123:12): [True: 39, False: 259]
  ------------------
  124|    259|           sp.type() == ModelProto::SentencePiece::USER_DEFINED ||
  ------------------
  |  Branch (124:12): [True: 0, False: 259]
  ------------------
  125|    259|           sp.type() == ModelProto::SentencePiece::UNUSED);
  ------------------
  |  Branch (125:12): [True: 0, False: 259]
  ------------------
  126|    298|      auto* target_map = is_normal_piece ? &pieces_ : &reserved_id_map_;
  ------------------
  |  Branch (126:26): [True: 39, False: 259]
  ------------------
  127|    298|      if (!target_map->emplace(sp.piece(), i).second) {
  ------------------
  |  Branch (127:11): [True: 0, False: 298]
  ------------------
  128|      0|        status_ = absl::InternalError(
  129|      0|            absl::StrCat(sp.piece(), " is already defined."));
  130|      0|        return;
  131|      0|      }
  132|    298|    } else if (!pieces_.emplace(sp.piece(), i).second) {
  ------------------
  |  Branch (132:16): [True: 0, False: 0]
  ------------------
  133|      0|      status_ =
  134|      0|          absl::InternalError(absl::StrCat(sp.piece(), " is already defined."));
  135|      0|      return;
  136|      0|    }
  137|       |
  138|    298|    if (sp.type() == ModelProto::SentencePiece::USER_DEFINED) {
  ------------------
  |  Branch (138:9): [True: 0, False: 298]
  ------------------
  139|      0|      user_defined_symbols.insert(sp.piece());
  140|      0|    }
  141|       |
  142|    298|    if (sp.type() == ModelProto::SentencePiece::UNKNOWN) {
  ------------------
  |  Branch (142:9): [True: 1, False: 297]
  ------------------
  143|      1|      if (unk_id_ >= 0) {
  ------------------
  |  Branch (143:11): [True: 0, False: 1]
  ------------------
  144|      0|        status_ = absl::InternalError("unk is already defined.");
  145|      0|        return;
  146|      0|      }
  147|      1|      unk_id_ = i;
  148|      1|    }
  149|       |
  150|    298|    if (sp.type() == ModelProto::SentencePiece::BYTE) {
  ------------------
  |  Branch (150:9): [True: 256, False: 42]
  ------------------
  151|    256|      if (!model_proto_->trainer_spec().byte_fallback()) {
  ------------------
  |  Branch (151:11): [True: 0, False: 256]
  ------------------
  152|      0|        status_ = absl::InternalError(
  153|      0|            absl::StrCat("byte piece ", sp.piece(),
  154|      0|                         " is found although `byte_fallback` is false."));
  155|      0|        return;
  156|      0|      }
  157|    256|      const int byte = PieceToByte(sp.piece());
  158|    256|      if (0 <= byte && byte < 256) {
  ------------------
  |  Branch (158:11): [True: 256, False: 0]
  |  Branch (158:24): [True: 256, False: 0]
  ------------------
  159|    256|        byte_found[byte] = true;
  160|    256|      } else {
  161|      0|        status_ = absl::InternalError(
  162|      0|            absl::StrCat("byte piece ", sp.piece(), " is invalid."));
  163|      0|        return;
  164|      0|      }
  165|    256|    }
  166|    298|  }
  167|       |
  168|      1|  if (unk_id_ == -1) {
  ------------------
  |  Branch (168:7): [True: 0, False: 1]
  ------------------
  169|      0|    status_ = absl::InternalError("unk is not defined.");
  170|      0|    return;
  171|      0|  }
  172|       |
  173|      1|  if (model_proto_->trainer_spec().byte_fallback()) {
  ------------------
  |  Branch (173:7): [True: 1, False: 0]
  ------------------
  174|       |    // Checks that there are 256 byte pieces.
  175|      1|    if (std::find(byte_found.begin(), byte_found.end(), false) !=
  ------------------
  |  Branch (175:9): [True: 0, False: 1]
  ------------------
  176|      1|        byte_found.end()) {
  177|      0|      status_ = absl::InternalError(
  178|      0|          "there are not 256 byte pieces although `byte_fallback` is true.");
  179|      0|      return;
  180|      0|    }
  181|      1|  }
  182|       |
  183|      1|  matcher_ = std::make_unique<normalizer::PrefixMatcher>(user_defined_symbols);
  184|      1|}
_ZN13sentencepiece11ByteToPieceEh:
  250|    256|const std::string& ByteToPiece(unsigned char c) {
  251|    256|  static const absl::NoDestructor<std::vector<std::string>> kBytePieces([] {
  252|    256|    std::vector<std::string> v(256);
  253|    256|    for (int i = 0; i < 256; ++i) {
  254|    256|      v[i] = absl::StrFormat("<0x%02X>", i);
  255|    256|    }
  256|    256|    return v;
  257|    256|  }());
  258|    256|  return (*kBytePieces)[c];
  259|    256|}
_ZN13sentencepiece11PieceToByteENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  261|    256|int PieceToByte(absl::string_view piece) {
  262|    256|  using PieceToByteMap = absl::flat_hash_map<absl::string_view, unsigned char>;
  263|    256|  static const absl::NoDestructor<PieceToByteMap> kMap([] {
  264|    256|    PieceToByteMap m;
  265|    256|    for (int i = 0; i < 256; ++i) {
  266|    256|      m[ByteToPiece(i)] = i;
  267|    256|    }
  268|    256|    return m;
  269|    256|  }());
  270|       |
  271|    256|  if (const auto it = kMap->find(piece); it != kMap->end()) {
  ------------------
  |  Branch (271:42): [True: 256, False: 0]
  ------------------
  272|    256|    return it->second;
  273|    256|  }
  274|       |
  275|      0|  return -1;
  276|    256|}
model_interface.cc:_ZZN13sentencepiece11ByteToPieceEhENK3$_0clEv:
  251|      1|  static const absl::NoDestructor<std::vector<std::string>> kBytePieces([] {
  252|      1|    std::vector<std::string> v(256);
  253|    257|    for (int i = 0; i < 256; ++i) {
  ------------------
  |  Branch (253:21): [True: 256, False: 1]
  ------------------
  254|    256|      v[i] = absl::StrFormat("<0x%02X>", i);
  255|    256|    }
  256|      1|    return v;
  257|      1|  }());
model_interface.cc:_ZZN13sentencepiece11PieceToByteENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEENK3$_0clEv:
  263|      1|  static const absl::NoDestructor<PieceToByteMap> kMap([] {
  264|      1|    PieceToByteMap m;
  265|    257|    for (int i = 0; i < 256; ++i) {
  ------------------
  |  Branch (265:21): [True: 256, False: 1]
  ------------------
  266|    256|      m[ByteToPiece(i)] = i;
  267|    256|    }
  268|      1|    return m;
  269|      1|  }());

_ZNK13sentencepiece14ModelInterface6statusEv:
   73|     10|  virtual absl::Status status() const { return status_; }
_ZNK13sentencepiece14ModelInterface14prefix_matcherEv:
   80|      1|      const {
   81|      1|    return matcher_.get();
   82|      1|  }
_ZNK13sentencepiece14ModelInterface9IsUnknownEi:
  146|      1|  [[nodiscard]] virtual bool IsUnknown(int id) const {
  147|      1|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|      1|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|      1|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      1|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 1]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      1|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  148|      1|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|      1|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|      1|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      1|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 1]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      1|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  149|      1|    return (model_proto_->pieces(id).type() ==
  150|      1|            ModelProto::SentencePiece::UNKNOWN);
  151|      1|  }
_ZNK13sentencepiece14ModelInterface9IsControlEi:
  154|      3|  [[nodiscard]] virtual bool IsControl(int id) const {
  155|      3|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|      3|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|      3|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      3|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 3]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      3|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  156|      3|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|      3|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|      3|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      3|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 3]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      3|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  157|      3|    return (model_proto_->pieces(id).type() ==
  158|      3|            ModelProto::SentencePiece::CONTROL);
  159|      3|  }
_ZN13sentencepiece14ModelInterfaceC2Ev:
   67|      1|  ModelInterface() = default;

_ZN13sentencepiece10normalizer10NormalizerC2ERKNS_14NormalizerSpecERKNS_11TrainerSpecE:
   42|      1|    : spec_(&spec),
   43|      1|      treat_whitespace_as_suffix_(trainer_spec.treat_whitespace_as_suffix()),
   44|      1|      status_(absl::OkStatus()) {
   45|      1|  Init();
   46|      1|}
_ZN13sentencepiece10normalizer10Normalizer4InitEv:
   55|      1|void Normalizer::Init() {
   56|      1|  absl::string_view index = spec_->precompiled_charsmap();
   57|       |
   58|      1|  if (!index.empty()) {
  ------------------
  |  Branch (58:7): [True: 0, False: 1]
  ------------------
   59|      0|    absl::string_view trie_blob;
   60|      0|    status_ = DecodePrecompiledCharsMap(index, &trie_blob, &normalized_,
   61|      0|                                        &precompiled_charsmap_buffer_);
   62|       |
   63|      0|    if (!status_.ok()) return;
  ------------------
  |  Branch (63:9): [True: 0, False: 0]
  ------------------
   64|       |
   65|       |    // Reads the body of double array.
   66|      0|    trie_ = std::make_unique<Darts::DoubleArray>();
   67|       |
   68|       |    // copy_array ensures correct alignment even if the trie_blob is
   69|       |    // mis-aligned. Although standard proto parsing copies data to the heap
   70|       |    // (guaranteeing alignment), zero-copy parsing or custom buffers might
   71|       |    // pass misaligned data.
   72|      0|    if (reinterpret_cast<uintptr_t>(trie_blob.data()) % 4 == 0) {
  ------------------
  |  Branch (72:9): [True: 0, False: 0]
  ------------------
   73|      0|      trie_->set_array(const_cast<char*>(trie_blob.data()),
   74|      0|                       trie_blob.size() / trie_->unit_size());
   75|      0|    } else {
   76|      0|      trie_->copy_array(reinterpret_cast<const char*>(trie_blob.data()),
   77|      0|                        trie_blob.size());
   78|      0|    }
   79|       |
   80|      0|    if (!trie_->validate(normalized_.size())) {
  ------------------
  |  Branch (80:9): [True: 0, False: 0]
  ------------------
   81|      0|      status_ = absl::InternalError("precompiled_charsmap is invalid.");
   82|      0|      trie_.reset();
   83|      0|      return;
   84|      0|    }
   85|      0|  }
   86|      1|}
_ZN13sentencepiece10normalizer13PrefixMatcherC2ERKNSt3__13setINS2_17basic_string_viewIcNS2_11char_traitsIcEEEENS2_4lessIS7_EENS2_9allocatorIS7_EEEE:
  339|      1|PrefixMatcher::PrefixMatcher(const std::set<absl::string_view>& dic) {
  340|      1|  if (dic.empty()) return;
  ------------------
  |  Branch (340:7): [True: 1, False: 0]
  ------------------
  341|      0|  std::vector<const char*> key;
  342|      0|  std::vector<size_t> lengths;
  343|      0|  key.reserve(dic.size());
  344|      0|  lengths.reserve(dic.size());
  345|      0|  for (const auto& it : dic) {
  ------------------
  |  Branch (345:23): [True: 0, False: 0]
  ------------------
  346|      0|    key.push_back(it.data());
  347|      0|    lengths.push_back(it.size());
  348|      0|  }
  349|      0|  trie_ = std::make_unique<Darts::DoubleArray>();
  350|      0|  if (trie_->build(key.size(), const_cast<char**>(key.data()),
  ------------------
  |  Branch (350:7): [True: 0, False: 0]
  ------------------
  351|      0|                   const_cast<size_t*>(lengths.data()), nullptr) != 0) {
  352|      0|    LOG(ERROR) << "Failed to build the TRIE for PrefixMatcher";
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  353|      0|    trie_.reset();
  354|      0|  }
  355|      0|}

_ZN13sentencepiece10normalizer10Normalizer16SetPrefixMatcherEPKNS0_13PrefixMatcherE:
   72|      1|  virtual void SetPrefixMatcher(const PrefixMatcher* matcher) {
   73|      1|    matcher_ = matcher;
   74|      1|  }
_ZNK13sentencepiece10normalizer10Normalizer6statusEv:
   78|      9|  virtual absl::Status status() const { return status_; }

_ZN13sentencepiece22SentencePieceProcessorC2Ev:
   75|      1|SentencePieceProcessor::SentencePieceProcessor() {}
_ZN13sentencepiece22SentencePieceProcessor23LoadFromSerializedProtoENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   95|      1|    absl::string_view serialized) {
   96|      1|  auto model_proto = std::make_unique<ModelProto>();
   97|      1|  RET_CHECK(model_proto->ParseFromArray(serialized.data(), serialized.size()));
  ------------------
  |  |   23|      1|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (23:7): [True: 1, False: 0]
  |  |  ------------------
  |  |   24|      1|  } else /* NOLINT */                                         \
  |  |   25|      1|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |   26|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   98|      1|  return Load(std::move(model_proto));
   99|      1|}
_ZN13sentencepiece22SentencePieceProcessor4LoadENSt3__110unique_ptrINS_10ModelProtoENS1_14default_deleteIS3_EEEE:
  102|      1|    std::unique_ptr<ModelProto> model_proto) {
  103|      1|  model_proto_ = std::move(model_proto);
  104|      1|  model_ = ModelFactory::Create(*model_proto_);
  105|      1|  normalizer_ = std::make_unique<normalizer::Normalizer>(
  106|      1|      model_proto_->normalizer_spec(), model_proto_->trainer_spec());
  107|      1|  if (model_proto_->has_denormalizer_spec() &&
  ------------------
  |  Branch (107:7): [True: 0, False: 1]
  ------------------
  108|      0|      !model_proto_->denormalizer_spec().precompiled_charsmap().empty()) {
  ------------------
  |  Branch (108:7): [True: 0, False: 0]
  ------------------
  109|      0|    denormalizer_ = std::make_unique<normalizer::Normalizer>(
  110|      0|        model_proto_->denormalizer_spec());
  111|      0|  }
  112|       |
  113|       |  // Escapes user-defined-symbols in normalizer.
  114|      1|  normalizer_->SetPrefixMatcher(model_->prefix_matcher());
  115|       |
  116|      1|  ABSL_RETURN_IF_ERROR(status());
  ------------------
  |  |   90|      1|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  ------------------
  |  |  |  |  162|      2|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  ------------------
  |  |  |  |  |  |  349|      2|  switch (0)                                           \
  |  |  |  |  |  |  350|      2|  case 0:                                              \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (350:3): [True: 1, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  351|      1|  default:  // NOLINT
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  163|      2|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (163:12): [True: 1, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  164|      2|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  165|      2|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  166|      1|  } else /* NOLINT */                                                     \
  |  |  |  |  167|      2|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  ------------------
  ------------------
  117|       |
  118|       |  // Precomputes and caches special token IDs.
  119|       |  // Note that these IDs are not always the same as the IDs in TrainerSpec.
  120|      1|  unk_id_ = PieceToId(model_->unk_piece());
  121|      1|  if (!IsUnknown(unk_id_)) unk_id_ = -1;
  ------------------
  |  Branch (121:7): [True: 0, False: 1]
  ------------------
  122|       |
  123|      1|  bos_id_ = PieceToId(model_->bos_piece());
  124|      1|  if (!IsControl(bos_id_)) bos_id_ = -1;
  ------------------
  |  Branch (124:7): [True: 0, False: 1]
  ------------------
  125|       |
  126|      1|  eos_id_ = PieceToId(model_->eos_piece());
  127|      1|  if (!IsControl(eos_id_)) eos_id_ = -1;
  ------------------
  |  Branch (127:7): [True: 0, False: 1]
  ------------------
  128|       |
  129|      1|  pad_id_ = PieceToId(model_->pad_piece());
  130|      1|  if (!IsControl(pad_id_)) pad_id_ = -1;
  ------------------
  |  Branch (130:7): [True: 1, False: 0]
  ------------------
  131|       |
  132|      1|  return absl::OkStatus();
  133|      1|}
_ZNK13sentencepiece22SentencePieceProcessor6statusEv:
  145|      9|absl::Status SentencePieceProcessor::status() const {
  146|      9|  RET_CHECK(model_) << "Model is not initialized.";
  ------------------
  |  |   23|      9|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (23:7): [True: 9, False: 0]
  |  |  ------------------
  |  |   24|      9|  } else /* NOLINT */                                         \
  |  |   25|      9|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |   26|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  147|      9|  RET_CHECK(normalizer_) << "Normalizer is not initialized.";
  ------------------
  |  |   23|      9|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (23:7): [True: 9, False: 0]
  |  |  ------------------
  |  |   24|      9|  } else /* NOLINT */                                         \
  |  |   25|      9|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |   26|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  148|      9|  ABSL_RETURN_IF_ERROR(model_->status());
  ------------------
  |  |   90|      9|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  ------------------
  |  |  |  |  162|     27|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  ------------------
  |  |  |  |  |  |  349|     18|  switch (0)                                           \
  |  |  |  |  |  |  350|     18|  case 0:                                              \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (350:3): [True: 9, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  351|      9|  default:  // NOLINT
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 9]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  163|     27|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (163:12): [True: 9, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  164|     27|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  165|     27|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  166|      9|  } else /* NOLINT */                                                     \
  |  |  |  |  167|     27|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  ------------------
  ------------------
  149|      9|  ABSL_RETURN_IF_ERROR(normalizer_->status());
  ------------------
  |  |   90|      9|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  ------------------
  |  |  |  |  162|     27|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  ------------------
  |  |  |  |  |  |  349|     18|  switch (0)                                           \
  |  |  |  |  |  |  350|     18|  case 0:                                              \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (350:3): [True: 9, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  351|      9|  default:  // NOLINT
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 9]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  163|     27|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (163:12): [True: 9, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  164|     27|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  165|     27|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  166|      9|  } else /* NOLINT */                                                     \
  |  |  |  |  167|     27|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  ------------------
  ------------------
  150|      9|  return absl::OkStatus();
  151|      9|}
_ZNK13sentencepiece22SentencePieceProcessor9PieceToIdENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
 1034|      4|int SentencePieceProcessor::PieceToId(absl::string_view piece) const {
 1035|      4|  RET_CHECK_OR_RETURN_DEFAULT(0);
  ------------------
  |  | 1005|      4|  if (!status().ok()) {                                                      \
  |  |  ------------------
  |  |  |  Branch (1005:7): [True: 0, False: 4]
  |  |  ------------------
  |  | 1006|      0|    LOG(ERROR) << status().message() << "\nReturns default value " << value; \
  |  |  ------------------
  |  |  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1007|      0|    return value;                                                            \
  |  | 1008|      0|  }
  ------------------
 1036|      4|  return model_->PieceToId(piece);
 1037|      4|}
_ZNK13sentencepiece22SentencePieceProcessor9IsControlEi:
 1059|      3|bool SentencePieceProcessor::IsControl(int id) const {
 1060|      3|  RET_CHECK_OR_RETURN_DEFAULT(0);
  ------------------
  |  | 1005|      3|  if (!status().ok()) {                                                      \
  |  |  ------------------
  |  |  |  Branch (1005:7): [True: 0, False: 3]
  |  |  ------------------
  |  | 1006|      0|    LOG(ERROR) << status().message() << "\nReturns default value " << value; \
  |  |  ------------------
  |  |  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1007|      0|    return value;                                                            \
  |  | 1008|      0|  }
  ------------------
 1061|      3|  return model_->IsControl(id);
 1062|      3|}
_ZNK13sentencepiece22SentencePieceProcessor9IsUnknownEi:
 1064|      1|bool SentencePieceProcessor::IsUnknown(int id) const {
 1065|      1|  RET_CHECK_OR_RETURN_DEFAULT(0);
  ------------------
  |  | 1005|      1|  if (!status().ok()) {                                                      \
  |  |  ------------------
  |  |  |  Branch (1005:7): [True: 0, False: 1]
  |  |  ------------------
  |  | 1006|      0|    LOG(ERROR) << status().message() << "\nReturns default value " << value; \
  |  |  ------------------
  |  |  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1007|      0|    return value;                                                            \
  |  | 1008|      0|  }
  ------------------
 1066|      1|  return model_->IsUnknown(id);
 1067|      1|}

_ZNK13sentencepiece7unigram5Model9PieceToIdENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  602|      4|int Model::PieceToId(absl::string_view piece) const {
  603|      4|  auto it = reserved_id_map_.find(piece);
  604|      4|  if (it != reserved_id_map_.end()) {
  ------------------
  |  Branch (604:7): [True: 3, False: 1]
  ------------------
  605|      3|    return it->second;
  606|      3|  }
  607|      1|  int id = 0;
  608|      1|  trie_->exactMatchSearch(piece.data(), id, piece.size());
  609|      1|  return id == -1 ? unk_id_ : id;
  ------------------
  |  Branch (609:10): [True: 1, False: 0]
  ------------------
  610|      4|}
_ZN13sentencepiece7unigram5Model9BuildTrieEPNSt3__16vectorINS2_4pairINS2_17basic_string_viewIcNS2_11char_traitsIcEEEEiEENS2_9allocatorIS9_EEEE:
  612|      1|void Model::BuildTrie(std::vector<std::pair<absl::string_view, int>>* pieces) {
  613|      1|  if (!status().ok()) return;
  ------------------
  |  Branch (613:7): [True: 0, False: 1]
  ------------------
  614|       |
  615|      1|  if (pieces->empty()) {
  ------------------
  |  Branch (615:7): [True: 0, False: 1]
  ------------------
  616|      0|    status_ = absl::InternalError("no pieces are loaded.");
  617|      0|    return;
  618|      0|  }
  619|       |
  620|       |  // sort by sentencepiece since DoubleArray::build()
  621|       |  // only accepts sorted strings.
  622|      1|  sort(pieces->begin(), pieces->end());
  623|       |
  624|       |  // Makes key/value/length set for DoubleArrayTrie.
  625|      1|  std::vector<const char*> key(pieces->size());
  626|      1|  std::vector<size_t> length(pieces->size());
  627|      1|  std::vector<int> value(pieces->size());
  628|     40|  for (size_t i = 0; i < pieces->size(); ++i) {
  ------------------
  |  Branch (628:22): [True: 39, False: 1]
  ------------------
  629|     39|    key[i] = (*pieces)[i].first.data();  // sorted piece.
  630|     39|    length[i] = (*pieces)[i].first.size();
  631|     39|    value[i] = (*pieces)[i].second;  // vocab_id
  632|     39|  }
  633|       |
  634|      1|  trie_ = std::make_unique<Darts::DoubleArray>();
  635|      1|  if (trie_->build(key.size(), const_cast<char**>(&key[0]),
  ------------------
  |  Branch (635:7): [True: 0, False: 1]
  ------------------
  636|      1|                   const_cast<size_t*>(&length[0]), &value[0]) != 0) {
  637|      0|    status_ = absl::InternalError("cannot build double-array.");
  638|      0|    return;
  639|      0|  }
  640|       |
  641|       |  // Computes the maximum number of shared prefixes in the trie.
  642|      1|  const int kMaxTrieResultsSize = 1024;
  643|      1|  std::vector<Darts::DoubleArray::result_pair_type> results(
  644|      1|      kMaxTrieResultsSize);
  645|      1|  trie_results_size_ = 0;
  646|     39|  for (const auto& p : *pieces) {
  ------------------
  |  Branch (646:22): [True: 39, False: 1]
  ------------------
  647|     39|    const int num_nodes = trie_->commonPrefixSearch(
  648|     39|        p.first.data(), results.data(), results.size(), p.first.size());
  649|     39|    trie_results_size_ = std::max(trie_results_size_, num_nodes);
  650|     39|  }
  651|       |
  652|      1|  pieces_.clear();
  653|       |
  654|      1|  if (trie_results_size_ == 0)
  ------------------
  |  Branch (654:7): [True: 0, False: 1]
  ------------------
  655|      0|    status_ = absl::InternalError("no entry is found in the trie.");
  656|      1|}
_ZN13sentencepiece7unigram5ModelC2ERKNS_10ModelProtoE:
  658|      1|Model::Model(const ModelProto& model_proto) {
  659|      1|  model_proto_ = &model_proto;
  660|       |
  661|      1|  InitializePieces(/* use_reserved_id_map= */ true);
  662|       |
  663|      1|  min_score_ = FLT_MAX;
  664|    298|  for (const auto& sp : model_proto_->pieces()) {
  ------------------
  |  Branch (664:23): [True: 298, False: 1]
  ------------------
  665|    298|    if (std::isnan(sp.score()) || std::isinf(sp.score())) {
  ------------------
  |  Branch (665:9): [True: 0, False: 298]
  |  Branch (665:35): [True: 0, False: 298]
  ------------------
  666|      0|      status_ = absl::InternalError("score is NaN or Inf.");
  667|      0|      return;
  668|      0|    }
  669|    298|    if (sp.type() == ModelProto::SentencePiece::NORMAL) {
  ------------------
  |  Branch (669:9): [True: 39, False: 259]
  ------------------
  670|     39|      min_score_ = std::min(min_score_, sp.score());
  671|     39|    }
  672|    298|  }
  673|       |
  674|      1|  std::vector<std::pair<absl::string_view, int>> pieces;
  675|     39|  for (const auto& it : pieces_) pieces.emplace_back(it.first, it.second);
  ------------------
  |  Branch (675:23): [True: 39, False: 1]
  ------------------
  676|       |
  677|      1|  BuildTrie(&pieces);
  678|      1|}

_ZN4absl12lts_2026081713little_endian8ToHost64Em:
  110|      5|inline uint64_t ToHost64(uint64_t x) { return x; }

_ZN4absl12lts_2026081713base_internal17HardeningAssertLTImmEEvT_T0_:
   92|    256|constexpr void HardeningAssertLT(T1 val1, T2 val2) {
   93|    256|  ABSL_ASSERT(val1 < val2);
  ------------------
  |  |  131|    256|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|    256|#define ABSL_INTERNAL_UNEVALUATED(expr) (decltype((void)(expr))())
  |  |  ------------------
  ------------------
   94|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
   95|       |  if (!ABSL_PREDICT_TRUE(val1 < val2)) {
   96|       |    ABSL_INTERNAL_HARDENING_ABORT();
   97|       |  }
   98|       |#endif
   99|    256|}

_ZN4absl12lts_2026081713base_internal15UnalignedLoad32EPKv:
   45|  2.44k|inline uint32_t UnalignedLoad32(const void* absl_nonnull p) {
   46|  2.44k|  uint32_t t;
   47|  2.44k|  memcpy(&t, p, sizeof t);
   48|  2.44k|  return t;
   49|  2.44k|}
_ZN4absl12lts_2026081713base_internal15UnalignedLoad64EPKv:
   51|  1.26k|inline uint64_t UnalignedLoad64(const void* absl_nonnull p) {
   52|  1.26k|  uint64_t t;
   53|  1.26k|  memcpy(&t, p, sizeof t);
   54|  1.26k|  return t;
   55|  1.26k|}

_ZN4absl12lts_2026081712NoDestructorINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEC2EOSB_:
  129|      1|      : impl_(std::move(x)) {}
_ZN4absl12lts_2026081712NoDestructorINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEE13PlacementImplC2IJSB_EEEDpOT_:
  160|      1|    explicit PlacementImpl(Args&&... args) {
  161|      1|      new (&space_) T(std::forward<Args>(args)...);
  162|      1|    }
_ZN4absl12lts_2026081712NoDestructorINS0_13flat_hash_mapINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhNS0_18container_internal10StringHashENS8_8StringEqENS3_9allocatorINS3_4pairIKS7_hEEEEEEEC2EOSG_:
  129|      1|      : impl_(std::move(x)) {}
_ZN4absl12lts_2026081712NoDestructorINS0_13flat_hash_mapINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhNS0_18container_internal10StringHashENS8_8StringEqENS3_9allocatorINS3_4pairIKS7_hEEEEEEE13PlacementImplC2IJSG_EEEDpOT_:
  160|      1|    explicit PlacementImpl(Args&&... args) {
  161|      1|      new (&space_) T(std::forward<Args>(args)...);
  162|      1|    }
_ZNK4absl12lts_2026081712NoDestructorINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEdeEv:
  140|    256|  const T& operator*() const { return *get(); }
_ZNK4absl12lts_2026081712NoDestructorINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEE3getEv:
  142|    256|  const T* absl_nonnull get() const { return impl_.get(); }
_ZNK4absl12lts_2026081712NoDestructorINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEE13PlacementImpl3getEv:
  163|    256|    const T* absl_nonnull get() const {
  164|    256|      return std::launder(reinterpret_cast<const T*>(&space_));
  165|    256|    }
_ZNK4absl12lts_2026081712NoDestructorINS0_13flat_hash_mapINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhNS0_18container_internal10StringHashENS8_8StringEqENS3_9allocatorINS3_4pairIKS7_hEEEEEEEptEv:
  141|    512|  const T* absl_nonnull operator->() const { return get(); }
_ZNK4absl12lts_2026081712NoDestructorINS0_13flat_hash_mapINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhNS0_18container_internal10StringHashENS8_8StringEqENS3_9allocatorINS3_4pairIKS7_hEEEEEEE3getEv:
  142|    512|  const T* absl_nonnull get() const { return impl_.get(); }
_ZNK4absl12lts_2026081712NoDestructorINS0_13flat_hash_mapINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhNS0_18container_internal10StringHashENS8_8StringEqENS3_9allocatorINS3_4pairIKS7_hEEEEEEE13PlacementImpl3getEv:
  163|    512|    const T* absl_nonnull get() const {
  164|    512|      return std::launder(reinterpret_cast<const T*>(&space_));
  165|    512|    }

_ZN4absl12lts_2026081720PrefetchToLocalCacheEPKv:
  146|  1.13k|    const void* addr) {
  147|  1.13k|  __builtin_prefetch(addr, 0, 3);
  148|  1.13k|}

_ZN4absl12lts_2026081713flat_hash_mapINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEhNS0_18container_internal10StringHashENS7_8StringEqENS2_9allocatorINS2_4pairIKS6_hEEEEEC2Ev:
  205|      1|  flat_hash_map() {}
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhE5valueEPNS3_4pairIKS7_hEE:
  705|    256|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhE7elementEPNS1_13map_slot_typeIS7_hEE:
  703|  1.22k|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhE5applyINS1_12EqualElementINS3_12basic_stringIcS6_NS3_9allocatorIcEEEENS1_8StringEqEEEJRNS3_4pairIKS7_hEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSL_DpOSM_:
  689|     12|  apply(F&& f, Args&&... args) {
  690|     12|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  691|     12|                                                   std::forward<Args>(args)...);
  692|     12|  }
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS3_4pairIKS7_hEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSH_DpOSI_:
  689|    442|  apply(F&& f, Args&&... args) {
  690|    442|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  691|    442|                                                   std::forward<Args>(args)...);
  692|    442|  }
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhE8transferINS3_9allocatorINS3_4pairIKS7_hEEEEEEDaPT_PNS1_13map_slot_typeIS7_hEESJ_:
  682|    439|                       slot_type* old_slot) {
  683|    439|    return slot_policy::transfer(alloc, new_slot, old_slot);
  684|    439|  }
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhE9constructINS3_9allocatorINS3_4pairIKS7_hEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKNS3_12basic_stringIcS6_NSA_IcEEEEEEENSI_IJEEEEEEvPT_PNS1_13map_slot_typeIS7_hEEDpOT0_:
  670|    256|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  671|    256|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  672|    256|  }
_ZN4absl12lts_2026081713flat_hash_mapINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEiNS0_18container_internal10StringHashENS7_8StringEqENS2_9allocatorINS2_4pairIKS6_iEEEEEC2Ev:
  205|      2|  flat_hash_map() {}
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE5applyINS1_12EqualElementIS7_NS1_8StringEqEEEJRNS3_4pairIKS7_iEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSH_DpOSI_:
  689|      3|  apply(F&& f, Args&&... args) {
  690|      3|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  691|      3|                                                   std::forward<Args>(args)...);
  692|      3|  }
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE7elementEPNS1_13map_slot_typeIS7_iEE:
  703|     54|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE5applyINS1_12raw_hash_setIS8_JEE19EmplaceDecomposableEJRKNS3_12basic_stringIcS6_NS3_9allocatorIcEEEERiEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSK_DpOSL_:
  689|    298|  apply(F&& f, Args&&... args) {
  690|    298|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  691|    298|                                                   std::forward<Args>(args)...);
  692|    298|  }
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE5applyINS1_12EqualElementINS3_12basic_stringIcS6_NS3_9allocatorIcEEEENS1_8StringEqEEEJRNS3_4pairIKS7_iEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSL_DpOSM_:
  689|      9|  apply(F&& f, Args&&... args) {
  690|      9|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  691|      9|                                                   std::forward<Args>(args)...);
  692|      9|  }
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE9constructINS3_9allocatorINS3_4pairIKS7_iEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKNS3_12basic_stringIcS6_NSA_IcEEEEEEENSI_IJRiEEEEEEvPT_PNS1_13map_slot_typeIS7_iEEDpOT0_:
  670|    298|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  671|    298|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  672|    298|  }
_ZN4absl12lts_2026081718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhE5applyINS1_12EqualElementIS7_NS1_8StringEqEEEJRNS3_4pairIKS7_hEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSH_DpOSI_:
  689|    256|  apply(F&& f, Args&&... args) {
  690|    256|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  691|    256|                                                   std::forward<Args>(args)...);
  692|    256|  }

_ZN4absl12lts_2026081718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEvE7elementIS9_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIS8_hEE:
   85|  1.22k|      -> decltype(P::element(slot)) {
   86|  1.22k|    return P::element(slot);
   87|  1.22k|  }
_ZN4absl12lts_2026081718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEvE8transferINS4_9allocatorINS4_4pairIKS8_hEEEEEEvPT_PNS1_13map_slot_typeIS8_hEESL_:
   75|    439|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|    439|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|    439|  }
_ZN4absl12lts_2026081718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEvE13transfer_implINS4_9allocatorINS4_4pairIKS8_hEEEES9_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeIS8_hEESN_NSA_5Rank2E:
  119|    439|                                                           old_slot)) {
  120|    439|    return P::transfer(alloc, new_slot, old_slot);
  121|    439|  }
_ZN4absl12lts_2026081718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEvE9constructINS4_9allocatorINS4_4pairIKS8_hEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_12basic_stringIcS7_NSC_IcEEEEEEENSK_IJEEEEEEvPT_PNS1_13map_slot_typeIS8_hEEDpOT0_:
   51|    256|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|    256|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|    256|  }
_ZN4absl12lts_2026081718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEvE20transfer_uses_memcpyEv:
   93|      1|  static constexpr bool transfer_uses_memcpy() {
   94|      1|    return std::is_same_v<decltype(transfer_impl<std::allocator<char>>(
   95|      1|                              nullptr, nullptr, nullptr, Rank2{})),
   96|      1|                          std::true_type>;
   97|      1|  }
_ZN4absl12lts_2026081718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE7elementIS9_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIS8_iEE:
   85|     54|      -> decltype(P::element(slot)) {
   86|     54|    return P::element(slot);
   87|     54|  }
_ZN4absl12lts_2026081718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE9constructINS4_9allocatorINS4_4pairIKS8_iEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_12basic_stringIcS7_NSC_IcEEEEEEENSK_IJRiEEEEEEvPT_PNS1_13map_slot_typeIS8_iEEDpOT0_:
   51|    298|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|    298|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|    298|  }

_ZNKR4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   90|  5.33k|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026081718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  245|  5.33k|  constexpr const ElemT<I>& get() const& {
  246|  5.33k|    return StorageT<I>::get();
  247|  5.33k|  }
_ZNR4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   91|  3.70k|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026081718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  240|  3.70k|  constexpr ElemT<I>& get() & {
  241|  3.70k|    return StorageT<I>::get();
  242|  3.70k|  }
_ZNR4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EE3getEv:
  104|    997|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026081718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  240|    997|  constexpr ElemT<I>& get() & {
  241|    997|    return StorageT<I>::get();
  242|    997|  }
_ZN4absl12lts_2026081718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEC2IS3_JS4_S5_S8_ETnNS6_9enable_ifIXsr3stdE13conjunction_vINS6_8negationINS6_7is_sameIFvS9_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS9_JSF_DpT0_EEEEEbE4typeELb1EEEOSF_DpOSM_:
  235|      3|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  236|      3|                                             std::forward<First>(first),
  237|      3|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S6_S7_SA_EEENS8_10in_place_tEDpOT_:
  125|     12|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  126|     12|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EEC2IS4_EENS8_10in_place_tEOT_:
   89|      4|      : value(std::forward<V>(v)) {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EEC2IS4_EENS8_10in_place_tEOT_:
  101|      3|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EEC2IS4_EENS8_10in_place_tEOT_:
  101|      3|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  101|      3|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026081718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi2EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  245|    280|  constexpr const ElemT<I>& get() const& {
  246|    280|    return StorageT<I>::get();
  247|    280|  }
_ZNKR4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EE3getEv:
  103|    280|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026081718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  245|  1.25k|  constexpr const ElemT<I>& get() const& {
  246|  1.25k|    return StorageT<I>::get();
  247|  1.25k|  }
_ZNKR4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  103|  1.25k|  constexpr const T& get() const& { return *this; }
_ZNR4absl12lts_2026081718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  240|      3|  constexpr ElemT<I>& get() & {
  241|      3|    return StorageT<I>::get();
  242|      3|  }
_ZNR4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  104|      3|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026081718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi2EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  240|      1|  constexpr ElemT<I>& get() & {
  241|      1|    return StorageT<I>::get();
  242|      1|  }
_ZNR4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EE3getEv:
  104|      1|  constexpr T& get() & { return *this; }
_ZN4absl12lts_2026081718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEC2IS3_JRS4_RS5_RS8_ETnNS6_9enable_ifIXsr3stdE13conjunction_vINS6_8negationINS6_7is_sameIFvS9_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS9_JSI_DpT0_EEEEEbE4typeELb1EEEOSI_DpOSP_:
  235|      1|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  236|      1|                                             std::forward<First>(first),
  237|      1|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_RS6_RS7_RSA_EEENS8_10in_place_tEDpOT_:
  125|      4|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  126|      4|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EEC2IRS4_EENS8_10in_place_tEOT_:
  101|      1|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EEC2IRS4_EENS8_10in_place_tEOT_:
  101|      1|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EEC2IRS6_EENS4_10in_place_tEOT_:
  101|      1|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}

_ZN4absl12lts_2026081718container_internal27SanitizerPoisonMemoryRegionEPKvm:
  236|    450|inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
  237|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  238|       |  ASAN_POISON_MEMORY_REGION(m, s);
  239|       |#endif
  240|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  241|       |  __msan_poison(m, s);
  242|       |#endif
  243|    450|  (void)m;
  244|    450|  (void)s;
  245|    450|}
_ZN4absl12lts_2026081718container_internal29SanitizerUnpoisonMemoryRegionEPKvm:
  247|  1.00k|inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
  248|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  249|       |  ASAN_UNPOISON_MEMORY_REGION(m, s);
  250|       |#endif
  251|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  252|       |  __msan_unpoison(m, s);
  253|       |#endif
  254|  1.00k|  (void)m;
  255|  1.00k|  (void)s;
  256|  1.00k|}
_ZN4absl12lts_2026081718container_internal13DecomposePairINS1_12EqualElementINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_8StringEqEEEJRNS4_4pairIKNS4_17basic_string_viewIcS7_EEhEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  222|     12|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  223|     12|  return memory_internal::DecomposePairImpl(
  224|     12|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  225|     12|}
_ZN4absl12lts_2026081718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS1_8StringEqEEERKNS5_17basic_string_viewIcS8_EENS5_5tupleIJRKhEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSI_IJSN_EEEEEclsr3stdE7declvalIT1_EEEEOSM_NS5_4pairISQ_SR_EE:
  156|     12|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  157|     12|  const auto& key = std::get<0>(p.first);
  158|     12|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  159|     12|                            std::move(p.second));
  160|     12|}
_ZNK4absl12lts_2026081718container_internal12EqualElementINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS1_8StringEqEEclINS3_17basic_string_viewIcS6_EEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKSE_EEENSI_IJRKhEEEEEEbRKT_DpOT0_:
  525|     12|  bool operator()(const K2& lhs, Args&&...) const {
  526|     12|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  484|     12|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  527|     12|  }
_ZN4absl12lts_2026081718container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhEENS3_4pairINS3_5tupleIJRKT_EEENSA_IJRKT0_EEEEERKNS9_ISB_SF_EE:
  203|    710|    const std::pair<F, S>& p) {
  204|    710|  return PairArgs(p.first, p.second);
  205|    710|}
_ZN4absl12lts_2026081718container_internal8PairArgsIRKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERKhEENS3_4pairINS3_5tupleIJOT_EEENSD_IJOT0_EEEEESF_SI_:
  197|    710|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  198|    710|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  199|    710|          std::forward_as_tuple(std::forward<S>(s))};
  200|    710|}
_ZN4absl12lts_2026081718container_internal23TypeErasedApplyToSlotFnINS1_10StringHashENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEELb1EEEmPKvPvm:
  538|      1|size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
  539|      1|  const auto* f = static_cast<const Fn*>(fn);
  540|      1|  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
  541|      1|}
_ZN4absl12lts_2026081718container_internal11HashElementINS1_10StringHashELb1EEC2ERKS3_m:
  491|  1.25k|  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
_ZNK4absl12lts_2026081718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEEmRKT_DpOT0_:
  494|    261|  size_t operator()(const K& key, Args&&...) const {
  495|    261|    if constexpr (kIsDefault) {
  496|       |      // TODO(b/384509507): resolve `no header providing
  497|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  498|       |      // Maybe we should make "internal/hash.h" be a separate library.
  499|    261|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  500|    261|    }
  501|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  502|      0|    return hash(key) ^ seed;
  503|    261|  }
_ZN4absl12lts_2026081718container_internal13DecomposePairINS1_11HashElementINS1_10StringHashELb1EEEJRNSt3__14pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEhEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSF_DpOSG_:
  222|    442|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  223|    442|  return memory_internal::DecomposePairImpl(
  224|    442|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  225|    442|}
_ZN4absl12lts_2026081718container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS1_10StringHashELb1EEERKNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEENS7_5tupleIJRKhEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS7_19piecewise_constructEEclsr3stdE7declvalINSE_IJSJ_EEEEEclsr3stdE7declvalIT1_EEEEOSI_NS7_4pairISM_SN_EE:
  156|    442|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  157|    442|  const auto& key = std::get<0>(p.first);
  158|    442|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  159|    442|                            std::move(p.second));
  160|    442|}
_ZNK4absl12lts_2026081718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSA_EEENSE_IJRKhEEEEEEmRKT_DpOT0_:
  494|    442|  size_t operator()(const K& key, Args&&...) const {
  495|    442|    if constexpr (kIsDefault) {
  496|       |      // TODO(b/384509507): resolve `no header providing
  497|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  498|       |      // Maybe we should make "internal/hash.h" be a separate library.
  499|    442|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  500|    442|    }
  501|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  502|      0|    return hash(key) ^ seed;
  503|    442|  }
_ZN4absl12lts_2026081718container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhE8transferINS3_9allocatorINS3_4pairIKS7_hEEEEEEDaPT_PNS1_13map_slot_typeIS7_hEESJ_:
  438|    439|                       slot_type* old_slot) {
  439|       |    // This should really just be
  440|       |    // typename absl::is_trivially_relocatable<value_type>::type()
  441|       |    // but std::pair is not trivially copyable in C++23 in some standard
  442|       |    // library versions.
  443|       |    // See https://github.com/llvm/llvm-project/pull/95444 for instance.
  444|    439|    auto is_relocatable = typename std::conjunction<
  445|    439|        absl::is_trivially_relocatable<typename value_type::first_type>,
  446|    439|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  447|    439|        type();
  448|       |
  449|    439|    emplace(new_slot);
  450|    439|    if (is_relocatable) {
  ------------------
  |  Branch (450:9): [True: 439, Folded]
  ------------------
  451|       |      // TODO(b/247130232,b/251814870): remove casts after fixing warnings.
  452|    439|      std::memcpy(static_cast<void*>(std::launder(&new_slot->value)),
  453|    439|                  static_cast<const void*>(&old_slot->value),
  454|    439|                  sizeof(value_type));
  455|    439|      return is_relocatable;
  456|    439|    }
  457|       |
  458|      0|    if (kMutableKeys::value) {
  ------------------
  |  Branch (458:9): [True: 0, Folded]
  ------------------
  459|      0|      std::allocator_traits<Allocator>::construct(
  460|      0|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  461|      0|    } else {
  462|      0|      std::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  463|      0|                                                  std::move(old_slot->value));
  464|      0|    }
  465|      0|    destroy(alloc, old_slot);
  466|      0|    return is_relocatable;
  467|    439|  }
_ZN4absl12lts_2026081718container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhE7emplaceEPNS1_13map_slot_typeIS7_hEE:
  364|    695|  static void emplace(slot_type* slot) {
  365|       |    // The construction of union doesn't do anything at runtime but it allows us
  366|       |    // to access its members without violating aliasing rules.
  367|    695|    new (slot) slot_type;
  368|    695|  }
_ZN4absl12lts_2026081718container_internal13map_slot_typeINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhEC2Ev:
  345|    695|  map_slot_type() {}
_ZN4absl12lts_2026081718container_internal7HashKeyINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEC2ERKS3_RKSA_:
  511|      2|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026081718container_internal7HashKeyINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEclEm:
  513|      1|  size_t operator()(size_t seed) const {
  514|      1|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  515|      1|  }
_ZNK4absl12lts_2026081718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJEEEmRKT_DpOT0_:
  494|    553|  size_t operator()(const K& key, Args&&...) const {
  495|    553|    if constexpr (kIsDefault) {
  496|       |      // TODO(b/384509507): resolve `no header providing
  497|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  498|       |      // Maybe we should make "internal/hash.h" be a separate library.
  499|    553|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  500|    553|    }
  501|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  502|      0|    return hash(key) ^ seed;
  503|    553|  }
_ZN4absl12lts_2026081718container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEhE9constructINS3_9allocatorINS3_4pairIKS7_hEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKNS3_12basic_stringIcS6_NSA_IcEEEEEEENSI_IJEEEEEEvPT_PNS1_13map_slot_typeIS7_hEEDpOT0_:
  393|    256|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  394|    256|    emplace(slot);
  395|    256|    if (kMutableKeys::value) {
  ------------------
  |  Branch (395:9): [True: 256, Folded]
  ------------------
  396|    256|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  397|    256|                                                  std::forward<Args>(args)...);
  398|    256|    } else {
  399|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  400|      0|                                                  std::forward<Args>(args)...);
  401|      0|    }
  402|    256|  }
_ZN4absl12lts_2026081718container_internal13DecomposePairINS1_12EqualElementINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS1_8StringEqEEEJRNS4_4pairIKS8_iEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSF_DpOSG_:
  222|      3|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  223|      3|  return memory_internal::DecomposePairImpl(
  224|      3|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  225|      3|}
_ZN4absl12lts_2026081718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_8StringEqEEERKS9_NS5_5tupleIJRKiEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSE_IJSJ_EEEEEclsr3stdE7declvalIT1_EEEEOSI_NS5_4pairISM_SN_EE:
  156|      3|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  157|      3|  const auto& key = std::get<0>(p.first);
  158|      3|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  159|      3|                            std::move(p.second));
  160|      3|}
_ZNK4absl12lts_2026081718container_internal12EqualElementINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_8StringEqEEclIS7_JRKNS3_21piecewise_construct_tENS3_5tupleIJRKS7_EEENSE_IJRKiEEEEEEbRKT_DpOT0_:
  525|      3|  bool operator()(const K2& lhs, Args&&...) const {
  526|      3|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  484|      3|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  527|      3|  }
_ZN4absl12lts_2026081718container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiEENS3_4pairINS3_5tupleIJRKT_EEENSA_IJRKT0_EEEEERKNS9_ISB_SF_EE:
  203|     12|    const std::pair<F, S>& p) {
  204|     12|  return PairArgs(p.first, p.second);
  205|     12|}
_ZN4absl12lts_2026081718container_internal8PairArgsIRKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERKiEENS3_4pairINS3_5tupleIJOT_EEENSD_IJOT0_EEEEESF_SI_:
  197|     12|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  198|     12|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  199|     12|          std::forward_as_tuple(std::forward<S>(s))};
  200|     12|}
_ZN4absl12lts_2026081718container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE7emplaceEPNS1_13map_slot_typeIS7_iEE:
  364|    298|  static void emplace(slot_type* slot) {
  365|       |    // The construction of union doesn't do anything at runtime but it allows us
  366|       |    // to access its members without violating aliasing rules.
  367|    298|    new (slot) slot_type;
  368|    298|  }
_ZN4absl12lts_2026081718container_internal13map_slot_typeINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiEC2Ev:
  345|    298|  map_slot_type() {}
_ZN4absl12lts_2026081718container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEiEEJEE19EmplaceDecomposableEJRKNS5_12basic_stringIcS8_NS5_9allocatorIcEEEERiEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSK_DpOSL_:
  222|    298|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  223|    298|  return memory_internal::DecomposePairImpl(
  224|    298|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  225|    298|}
_ZN4absl12lts_2026081718container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEiEEJEE19EmplaceDecomposableERKNS6_12basic_stringIcS9_NS6_9allocatorIcEEEENS6_5tupleIJRiEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSK_IJSO_EEEEEclsr3stdE7declvalIT1_EEEEOSN_NS6_4pairISR_SS_EE:
  156|    298|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  157|    298|  const auto& key = std::get<0>(p.first);
  158|    298|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  159|    298|                            std::move(p.second));
  160|    298|}
_ZN4absl12lts_2026081718container_internal13DecomposePairINS1_12EqualElementINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_8StringEqEEEJRNS4_4pairIKNS4_17basic_string_viewIcS7_EEiEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  222|      9|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  223|      9|  return memory_internal::DecomposePairImpl(
  224|      9|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  225|      9|}
_ZN4absl12lts_2026081718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS1_8StringEqEEERKNS5_17basic_string_viewIcS8_EENS5_5tupleIJRKiEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSI_IJSN_EEEEEclsr3stdE7declvalIT1_EEEEOSM_NS5_4pairISQ_SR_EE:
  156|      9|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  157|      9|  const auto& key = std::get<0>(p.first);
  158|      9|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  159|      9|                            std::move(p.second));
  160|      9|}
_ZNK4absl12lts_2026081718container_internal12EqualElementINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS1_8StringEqEEclINS3_17basic_string_viewIcS6_EEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKSE_EEENSI_IJRKiEEEEEEbRKT_DpOT0_:
  525|      9|  bool operator()(const K2& lhs, Args&&...) const {
  526|      9|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  484|      9|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  527|      9|  }
_ZN4absl12lts_2026081718container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE9constructINS3_9allocatorINS3_4pairIKS7_iEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKNS3_12basic_stringIcS6_NSA_IcEEEEEEENSI_IJRiEEEEEEvPT_PNS1_13map_slot_typeIS7_iEEDpOT0_:
  393|    298|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  394|    298|    emplace(slot);
  395|    298|    if (kMutableKeys::value) {
  ------------------
  |  Branch (395:9): [True: 298, Folded]
  ------------------
  396|    298|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  397|    298|                                                  std::forward<Args>(args)...);
  398|    298|    } else {
  399|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  400|      0|                                                  std::forward<Args>(args)...);
  401|      0|    }
  402|    298|  }
_ZN4absl12lts_2026081718container_internal8PairArgsIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERiEENS3_4pairINS3_5tupleIJOT_EEENSE_IJOT0_EEEEESG_SJ_:
  197|    298|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  198|    298|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  199|    298|          std::forward_as_tuple(std::forward<S>(s))};
  200|    298|}
_ZN4absl12lts_2026081718container_internal13DecomposePairINS1_12EqualElementINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS1_8StringEqEEEJRNS4_4pairIKS8_hEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSF_DpOSG_:
  222|    256|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  223|    256|  return memory_internal::DecomposePairImpl(
  224|    256|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  225|    256|}
_ZN4absl12lts_2026081718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_8StringEqEEERKS9_NS5_5tupleIJRKhEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSE_IJSJ_EEEEEclsr3stdE7declvalIT1_EEEEOSI_NS5_4pairISM_SN_EE:
  156|    256|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  157|    256|  const auto& key = std::get<0>(p.first);
  158|    256|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  159|    256|                            std::move(p.second));
  160|    256|}
_ZNK4absl12lts_2026081718container_internal12EqualElementINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_8StringEqEEclIS7_JRKNS3_21piecewise_construct_tENS3_5tupleIJRKS7_EEENSE_IJRKhEEEEEEbRKT_DpOT0_:
  525|    256|  bool operator()(const K2& lhs, Args&&...) const {
  526|    256|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  484|    256|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  527|    256|  }

_ZNK4absl12lts_2026081718container_internal10StringHash14hash_with_seedENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEm:
   86|  1.25k|  size_t hash_with_seed(absl::string_view v, size_t seed) const {
   87|  1.25k|    return absl::hash_internal::HashWithSeed().hash(
   88|  1.25k|        absl::Hash<absl::string_view>{}, v, seed);
   89|  1.25k|  }
_ZNK4absl12lts_2026081718container_internal8StringEqclENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEES7_:
   98|    280|  bool operator()(absl::string_view lhs, absl::string_view rhs) const {
   99|    280|    return lhs == rhs;
  100|    280|  }

_ZN4absl12lts_2026081718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEvE5applyINS1_12EqualElementINS4_12basic_stringIcS7_NS4_9allocatorIcEEEENS1_8StringEqEEEJRNS4_4pairIKS8_hEEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSO_DpOSP_:
  130|     12|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|     12|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|     12|  }
_ZN4absl12lts_2026081718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS4_4pairIKS8_hEEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSK_DpOSL_:
  130|    442|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|    442|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|    442|  }
_ZN4absl12lts_2026081718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE5applyINS1_12EqualElementIS8_NS1_8StringEqEEEJRNS4_4pairIKS8_iEEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSK_DpOSL_:
  130|      3|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|      3|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|      3|  }
_ZN4absl12lts_2026081718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE5applyINS1_12raw_hash_setIS9_JEE19EmplaceDecomposableEJRKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEERiES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSN_DpOSO_:
  130|    298|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|    298|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|    298|  }
_ZN4absl12lts_2026081718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE5applyINS1_12EqualElementINS4_12basic_stringIcS7_NS4_9allocatorIcEEEENS1_8StringEqEEEJRNS4_4pairIKS8_iEEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSO_DpOSP_:
  130|      9|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|      9|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|      9|  }
_ZN4absl12lts_2026081718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEvE5applyINS1_12EqualElementIS8_NS1_8StringEqEEEJRNS4_4pairIKS8_hEEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSK_DpOSL_:
  130|    256|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|    256|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|    256|  }

_ZN4absl12lts_2026081718container_internal13GroupSse2ImplC2EPKNS1_6ctrl_tE:
  286|    877|  explicit GroupSse2Impl(const ctrl_t* pos) {
  287|    877|    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
  288|    877|  }
_ZNK4absl12lts_2026081718container_internal13GroupSse2Impl5MatchEh:
  291|    833|  BitMaskType Match(h2_t hash) const {
  292|    833|    auto match = _mm_set1_epi8(static_cast<char>(hash));
  293|    833|    return BitMaskType(MoveMask(_mm_cmpeq_epi8(match, ctrl)));
  294|    833|  }
_ZNK4absl12lts_2026081718container_internal13GroupSse2Impl9MaskEmptyEv:
  297|    574|  NonIterableBitMaskType MaskEmpty() const {
  298|       |#ifdef ABSL_INTERNAL_HAVE_SSSE3
  299|       |    // This only works because ctrl_t::kEmpty is -128.
  300|       |    return NonIterableBitMaskType(MoveMask(_mm_sign_epi8(ctrl, ctrl)));
  301|       |#else
  302|    574|    auto match = _mm_set1_epi8(static_cast<char>(ctrl_t::kEmpty));
  303|    574|    return NonIterableBitMaskType(MoveMask(_mm_cmpeq_epi8(match, ctrl)));
  304|    574|#endif
  305|    574|  }
_ZNK4absl12lts_2026081718container_internal13GroupSse2Impl8MaskFullEv:
  310|     31|  BitMaskType MaskFull() const { return BitMaskType(MoveMask(ctrl) ^ 0xffff); }
_ZNK4absl12lts_2026081718container_internal13GroupSse2Impl11MaskNonFullEv:
  315|      8|  auto MaskNonFull() const { return BitMaskType(MoveMask(ctrl)); }
_ZN4absl12lts_2026081718container_internal13GroupSse2Impl8MoveMaskEDv2_x:
  346|  1.45k|  static MaskInt MoveMask(__m128i xmm) {
  347|  1.45k|    auto mask = static_cast<MaskInt>(_mm_movemask_epi8(xmm));
  348|  1.45k|#ifdef __clang__
  349|       |    // TODO(b/472522597): Without the inline asm, clang ends up generating an
  350|       |    // unnecessary movzx to zero the upper bits of the output, but those bits
  351|       |    // are already zero. See https://godbolt.org/z/G6xW1Ecbx.
  352|  1.45k|    asm("" : "+r"(mask));  // NOLINT
  353|  1.45k|#endif
  354|  1.45k|    return mask;
  355|  1.45k|  }
_ZN4absl12lts_2026081718container_internal16IsEmptyOrDeletedENS1_6ctrl_tE:
  230|     69|inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
_ZN4absl12lts_2026081718container_internal13TrailingZerosImEEjT_:
   63|     15|uint32_t TrailingZeros(T x) {
   64|     15|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  272|     15|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
   65|     15|  return static_cast<uint32_t>(countr_zero(x));
   66|     15|}
_ZN4absl12lts_2026081718container_internal7BitMaskIjLi16ELi0ELb0EEC2Ej:
  133|  1.73k|  explicit BitMask(T mask) : Base(mask) {
  134|  1.73k|    if (Shift == 3 && !NullifyBitsOnIteration) {
  ------------------
  |  Branch (134:9): [Folded, False: 1.73k]
  |  Branch (134:23): [True: 0, Folded]
  ------------------
  135|       |      ABSL_SWISSTABLE_ASSERT(this->mask_ == (this->mask_ & kMsbs8Bytes));
  ------------------
  |  |   58|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  136|      0|    }
  137|  1.73k|  }
_ZN4absl12lts_2026081718container_internal18NonIterableBitMaskIjLi16ELi0EEC2Ej:
   85|  2.31k|  explicit NonIterableBitMask(T mask) : mask_(mask) {}
_ZNK4absl12lts_2026081718container_internal7BitMaskIjLi16ELi0ELb0EE5beginEv:
  153|    864|  BitMask begin() const { return *this; }
_ZNK4absl12lts_2026081718container_internal7BitMaskIjLi16ELi0ELb0EE3endEv:
  154|    864|  BitMask end() const { return BitMask(0); }
_ZN4absl12lts_2026081718container_internalneERKNS1_7BitMaskIjLi16ELi0ELb0EEES5_:
  160|  1.32k|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  161|  1.32k|    return a.mask_ != b.mask_;
  162|  1.32k|  }
_ZNK4absl12lts_2026081718container_internal7BitMaskIjLi16ELi0ELb0EEdeEv:
  151|    721|  uint32_t operator*() const { return Base::LowestBitSet(); }
_ZNK4absl12lts_2026081718container_internal18NonIterableBitMaskIjLi16ELi0EE12LowestBitSetEv:
   90|  1.27k|  uint32_t LowestBitSet() const {
   91|  1.27k|    return container_internal::TrailingZeros(mask_) >> Shift;
   92|  1.27k|  }
_ZN4absl12lts_2026081718container_internal13TrailingZerosIjEEjT_:
   63|  1.27k|uint32_t TrailingZeros(T x) {
   64|  1.27k|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  272|  1.27k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
   65|  1.27k|  return static_cast<uint32_t>(countr_zero(x));
   66|  1.27k|}
_ZNK4absl12lts_2026081718container_internal18NonIterableBitMaskIjLi16ELi0EEcvbEv:
   87|    587|  explicit operator bool() const { return mask_ != 0; }
_ZN4absl12lts_2026081718container_internal7BitMaskIjLi16ELi0ELb0EEppEv:
  143|    462|  BitMask& operator++() {
  144|    462|    if (Shift == 3 && NullifyBitsOnIteration) {
  ------------------
  |  Branch (144:9): [Folded, False: 462]
  |  Branch (144:23): [Folded, False: 0]
  ------------------
  145|      0|      this->mask_ &= kMsbs8Bytes;
  146|      0|    }
  147|    462|    this->mask_ &= (this->mask_ - 1);
  148|    462|    return *this;
  149|    462|  }

_ZN4absl12lts_2026081718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEEC2Ev:
  107|      1|  raw_hash_map() {}
_ZN4absl12lts_2026081718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEEixINS4_12basic_stringIcS7_NS4_9allocatorIcEEEES9_TpTnRiJETnNS4_9enable_ifIXsr14LifetimeBoundKIT_Lb1EPSI_EE5valueEiE4typeELi0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS4_4pairIKS8_hEEEESJ_RSI_EclL_ZNS4_7declvalB8ne220000IRSQ_EEDTclsr3stdE9__declvalISI_ELi0EEEvEEEEERKSI_:
  339|    256|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  340|    256|    return this->template operator[]<K, P, 0>(key);
  341|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEEixINS4_12basic_stringIcS7_NS4_9allocatorIcEEEES9_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS4_4pairIKS8_hEEEEPT_RSL_EclL_ZNS4_7declvalB8ne220000IRSK_EEDTclsr3stdE9__declvalISL_ELi0EEEvEEEEERKSL_:
  329|    256|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  330|       |    // It is safe to use unchecked_deref here because try_emplace
  331|       |    // will always return an iterator pointing to a valid item in the table,
  332|       |    // since it inserts if nothing is found for the given key.
  333|    256|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  334|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE11try_emplaceINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEJETnNS4_9enable_ifIXsr14LifetimeBoundKIT_Lb1EPSH_EE5valueEiE4typeELi0ETnNSG_IXntsr3stdE16is_convertible_vISH_NS1_12raw_hash_setIS9_JEE14const_iteratorEEEiE4typeELi0EEENS4_4pairINSM_8iteratorEbEERKSH_DpOT0_:
  253|    256|      Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
  254|    256|    return this->template try_emplace<K, 0>(k, std::forward<Args>(args)...);
  255|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE11try_emplaceINS4_12basic_stringIcS7_NS4_9allocatorIcEEEELi0EJETnNS4_9enable_ifIXntsr3stdE16is_convertible_vIT_NS1_12raw_hash_setIS9_JEE14const_iteratorEEEiE4typeELi0EEENS4_4pairINSJ_8iteratorEbEERKSH_DpOT1_:
  245|    256|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  246|    256|    return try_emplace_impl(k, std::forward<Args>(args)...);
  247|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE16try_emplace_implIRKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEJEEENS4_4pairINS1_12raw_hash_setIS9_JEE8iteratorEbEEOT_DpOT0_:
  365|    256|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  366|    256|    auto res = this->find_or_prepare_insert(k);
  367|    256|    if (res.second) {
  ------------------
  |  Branch (367:9): [True: 256, False: 0]
  ------------------
  368|    256|      this->emplace_at(res.first, std::piecewise_construct,
  369|    256|                       std::forward_as_tuple(std::forward<K>(k)),
  370|    256|                       std::forward_as_tuple(std::forward<Args>(args)...));
  371|    256|    }
  372|    256|    return {this->non_iterable_iterator_at_slot(res.first), res.second};
  373|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEEC2Ev:
  107|      2|  raw_hash_map() {}

_ZNK4absl12lts_2026081718container_internal12PerTableSeed4seedEv:
  603|  1.25k|  size_t seed() const { return seed_; }
_ZN4absl12lts_2026081718container_internal12PerTableSeedC2Em:
  610|  1.25k|      : seed_(static_cast<uint16_t>(seed)) {}
_ZNK4absl12lts_2026081718container_internal34CommonFieldsGenerationInfoDisabled14generation_ptrEv:
  939|  1.07k|  GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2026081718container_internal37HashSetIteratorGenerationInfoDisabledC2EPKh:
  963|  1.07k|  explicit HashSetIteratorGenerationInfoDisabled(const GenerationType*) {}
_ZNK4absl12lts_2026081718container_internal37HashSetIteratorGenerationInfoDisabled10generationEv:
  965|  1.19k|  GenerationType generation() const { return 0; }
_ZNK4absl12lts_2026081718container_internal37HashSetIteratorGenerationInfoDisabled14generation_ptrEv:
  967|  1.79k|  const GenerationType* generation_ptr() const { return nullptr; }
_ZNK4absl12lts_2026081718container_internal9HeapOrSoo7controlEv:
 1263|  4.72k|  MaybeInitializedPtr<ctrl_t> control() const {
 1264|  4.72k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.control);
  ------------------
  |  |  484|  4.72k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1265|  4.72k|  }
_ZN4absl12lts_2026081718container_internal12CommonFieldsC2ENS1_13non_soo_tag_tE:
 1294|      4|      : inline_data_(HashtableCapacity(0), no_seed_empty_tag_t{}) {}
_ZNK4absl12lts_2026081718container_internal12CommonFields7controlEv:
 1321|  4.72k|  ctrl_t* control() const {
 1322|  4.72k|    ABSL_SWISSTABLE_ASSERT(capacity() > 0);
  ------------------
  |  |  257|  4.72k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1323|       |    // Assume that the control bytes don't alias `this`.
 1324|  4.72k|    ctrl_t* ctrl = heap_or_soo_.control().get();
 1325|  4.72k|    [[maybe_unused]] size_t num_control_bytes = NumControlBytes(capacity());
 1326|  4.72k|    ABSL_ASSUME(reinterpret_cast<uintptr_t>(ctrl + num_control_bytes) <=
  ------------------
  |  |  272|  7.61k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (272:44): [True: 1.82k, False: 2.89k]
  |  |  |  Branch (272:44): [True: 2.89k, False: 0]
  |  |  ------------------
  ------------------
 1327|  4.72k|                    reinterpret_cast<uintptr_t>(this) ||
 1328|  4.72k|                reinterpret_cast<uintptr_t>(this + 1) <=
 1329|  4.72k|                    reinterpret_cast<uintptr_t>(ctrl));
 1330|  4.72k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(ctrl);
  ------------------
  |  |  484|  4.72k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1331|  4.72k|  }
_ZNK4absl12lts_2026081718container_internal12CommonFields10slot_arrayEm:
 1341|  1.93k|  void* slot_array(size_t capacity) const {
 1342|       |    ABSL_SWISSTABLE_ASSERT(capacity == this->capacity());
  ------------------
  |  |  257|  1.93k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1343|  1.93k|    ctrl_t* ctrl = control();
 1344|  1.93k|    return ctrl + NumControlBytes(capacity);
 1345|  1.93k|  }
_ZNK4absl12lts_2026081718container_internal12CommonFields4sizeEv:
 1348|     14|  size_t size() const { return inline_data_.size(); }
_ZNK4absl12lts_2026081718container_internal12CommonFields4seedEv:
 1380|  1.25k|  PerTableSeed seed() const { return inline_data_.seed(); }
_ZNK4absl12lts_2026081718container_internal12CommonFields13capacity_implEv:
 1395|  7.25k|  HashtableCapacity capacity_impl() const {
 1396|  7.25k|    HashtableCapacity cap = inline_data_.capacity();
 1397|       |    ABSL_SWISSTABLE_ASSERT(cap.IsValid());
  ------------------
  |  |  257|  7.25k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1398|  7.25k|    return cap;
 1399|  7.25k|  }
_ZNK4absl12lts_2026081718container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE8capacityEv:
  551|  7.26k|  constexpr size_t capacity() const {
  552|  7.26k|    ABSL_SWISSTABLE_ASSERT(IsValid());
  ------------------
  |  |  257|  7.26k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  553|  7.26k|    return StorageMode == kCapacityByValue ? capacity_data_
  ------------------
  |  Branch (553:12): [Folded, False: 7.26k]
  ------------------
  554|  7.26k|                                           : (size_t{1} << capacity_data_) - 1;
  555|  7.26k|  }
_ZNK4absl12lts_2026081718container_internal12CommonFields8capacityEv:
 1400|  7.24k|  size_t capacity() const { return capacity_impl().capacity(); }
_ZNK4absl12lts_2026081718container_internal12CommonFields8is_smallEv:
 1410|    818|  bool is_small() const { return inline_data_.is_small(); }
_ZNK4absl12lts_2026081718container_internal12CommonFields22AssertNotDebugCapacityEv:
 1498|  1.08k|  void AssertNotDebugCapacity() const {
 1499|  1.08k|    if (!SwisstableGenerationsOrDebugEnabled()) {
  ------------------
  |  Branch (1499:9): [True: 1.08k, Folded]
  ------------------
 1500|  1.08k|      return;
 1501|  1.08k|    }
 1502|      0|    AssertNotDebugCapacityImpl();
 1503|      0|  }
_ZN4absl12lts_2026081718container_internal21InsertIteratorControlEv:
  351|    554|inline ctrl_t* InsertIteratorControl() {
  352|       |  // Const must be cast away here; no uses of this function will actually write
  353|       |  // to it because it is only used for iterators returned by `insert` and
  354|       |  // similar.
  355|    554|  return const_cast<ctrl_t*>(kInsertIteratorControl);
  356|    554|}
_ZN4absl12lts_2026081718container_internal11SooCapacityEv:
  378|      2|constexpr size_t SooCapacity() { return 1; }
_ZN4absl12lts_2026081718container_internal15IsValidCapacityEm:
  395|    554|constexpr bool IsValidCapacity(size_t n) { return ((n + 1) & n) == 0 && n > 0; }
  ------------------
  |  Branch (395:51): [True: 554, False: 0]
  |  Branch (395:73): [True: 553, False: 1]
  ------------------
_ZN4absl12lts_2026081718container_internal15IsSmallCapacityEm:
  398|  6.69k|constexpr bool IsSmallCapacity(size_t capacity) {
  399|  6.69k|  return capacity <= kMaxSmallCapacity;
  400|  6.69k|}
_ZN4absl12lts_2026081718container_internal16PreviousCapacityEm:
  426|      5|constexpr size_t PreviousCapacity(size_t n) {
  427|       |  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(n));
  ------------------
  |  |  257|      5|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  428|      5|  return n / 2;
  429|      5|}
_ZN4absl12lts_2026081718container_internal2H1Em:
  832|  1.26k|inline size_t H1(size_t hash) { return hash; }
_ZN4absl12lts_2026081718container_internal2H2Em:
  837|  1.80k|inline h2_t H2(size_t hash) { return hash >> (sizeof(size_t) * 8 - 7); }
_ZN4absl12lts_2026081718container_internal14NumClonedBytesEv:
 1149|  7.80k|constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
_ZN4absl12lts_2026081718container_internal15NumControlBytesEm:
 1152|  6.67k|constexpr size_t NumControlBytes(size_t capacity) {
 1153|  6.67k|  return IsSmallCapacity(capacity) ? 0 : capacity + 1 + NumClonedBytes();
  ------------------
  |  Branch (1153:10): [True: 6, False: 6.66k]
  ------------------
 1154|  6.67k|}
_ZN4absl12lts_2026081718container_internal12AssertIsFullERKPKNS1_6ctrl_tEPKvhPKhPKc:
 1589|    596|                         const char* operation) {
 1590|    596|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1590:7): [True: 596, Folded]
  ------------------
 1591|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1592|       |  // enabled. To minimize their impact in those builds:
 1593|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1594|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1595|       |  //   the chances that the hot paths will be inlined.
 1596|      0|  if (ABSL_PREDICT_FALSE(slot == nullptr)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1597|      0|    ABSL_RAW_LOG(FATAL, "%s called on end() iterator.", operation);
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL 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]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1598|      0|  }
 1599|      0|  if (ABSL_PREDICT_FALSE(slot == DefaultIterSlot())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1600|      0|    ABSL_RAW_LOG(FATAL, "%s called on default-constructed iterator.",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL 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]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1601|      0|                 operation);
 1602|      0|  }
 1603|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1603:7): [Folded, False: 0]
  ------------------
 1604|      0|    if (ABSL_PREDICT_FALSE(generation !=
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1605|      0|                           CrashIfIteratorIsInvalid(generation_ptr))) {
 1606|      0|      ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL 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]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1607|      0|                   "%s called on invalid iterator. The table could have "
 1608|      0|                   "rehashed or moved since this iterator was initialized.",
 1609|      0|                   operation);
 1610|      0|    }
 1611|      0|    if (ABSL_PREDICT_FALSE(!IsFull(CrashIfIteratorIsInvalid(ctrl)))) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1612|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL 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]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1613|      0|          FATAL,
 1614|      0|          "%s called on invalid iterator. The element was likely erased.",
 1615|      0|          operation);
 1616|      0|    }
 1617|      0|  } else {
 1618|      0|    if (ABSL_PREDICT_FALSE(!IsFull(CrashIfIteratorIsInvalid(ctrl)))) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1619|       |      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL 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]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1620|      0|          FATAL,
 1621|      0|          "%s called on invalid iterator. The element might have been erased "
 1622|      0|          "or the table might have rehashed. Consider running with "
 1623|      0|          "--config=asan to diagnose rehashing issues.",
 1624|      0|          operation);
 1625|      0|    }
 1626|      0|  }
 1627|      0|}
_ZN4absl12lts_2026081718container_internal26AssertIsValidForComparisonERKPKNS1_6ctrl_tEPKvhPKh:
 1633|    600|                                       const GenerationType* generation_ptr) {
 1634|    600|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1634:7): [True: 600, Folded]
  ------------------
 1635|      0|  const bool ctrl_is_valid_for_comparison =
 1636|      0|      slot == nullptr || slot == DefaultIterSlot() ||
  ------------------
  |  Branch (1636:7): [True: 0, False: 0]
  |  Branch (1636:26): [True: 0, False: 0]
  ------------------
 1637|      0|      IsFull(CrashIfIteratorIsInvalid(ctrl));
  ------------------
  |  Branch (1637:7): [True: 0, False: 0]
  ------------------
 1638|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1638:7): [Folded, False: 0]
  ------------------
 1639|      0|    if (ABSL_PREDICT_FALSE(generation !=
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1640|      0|                           CrashIfIteratorIsInvalid(generation_ptr))) {
 1641|       |      // Note: in the case of a rehash, we would expect to see a sanitizer crash
 1642|       |      // in CrashIfIteratorIsInvalid so this assertion will only catch moved
 1643|       |      // table cases, unless we're using a custom allocator that does not
 1644|       |      // deallocate the old backing array (e.g. an arena allocator).
 1645|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL 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]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1646|      0|          FATAL,
 1647|      0|          "Invalid iterator comparison. The table was likely moved (or "
 1648|      0|          "possibly rehashed) since this iterator was initialized.");
 1649|      0|    }
 1650|      0|    if (ABSL_PREDICT_FALSE(!ctrl_is_valid_for_comparison)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1651|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL 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]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1652|      0|          FATAL, "Invalid iterator comparison. The element was likely erased.");
 1653|      0|    }
 1654|      0|  } else {
 1655|      0|    ABSL_HARDENING_ASSERT_SLOW(
  ------------------
  |  |  188|      0|#define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  131|      0|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define ABSL_INTERNAL_UNEVALUATED(expr) (decltype((void)(expr))())
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1656|      0|        ctrl_is_valid_for_comparison &&
 1657|      0|        "Invalid iterator comparison. The element might have been erased or "
 1658|      0|        "the table might have rehashed. Consider running with --config=asan to "
 1659|      0|        "diagnose rehashing issues.");
 1660|      0|  }
 1661|      0|}
_ZN4absl12lts_2026081718container_internal19AssertSameContainerERKPKNS1_6ctrl_tES6_PKvS8_PKhSA_:
 1694|    300|                                const GenerationType* generation_ptr_b) {
 1695|    300|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1695:7): [True: 300, Folded]
  ------------------
 1696|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1697|       |  // enabled. To minimize their impact in those builds:
 1698|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1699|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1700|       |  //   the chances that the hot paths will be inlined.
 1701|       |
 1702|       |  // fail_if(is_invalid, message) crashes when is_invalid is true and provides
 1703|       |  // an error message based on `message`.
 1704|      0|  const auto fail_if = [](bool is_invalid, const char* message) {
 1705|      0|    if (ABSL_PREDICT_FALSE(is_invalid)) {
 1706|      0|      ABSL_RAW_LOG(FATAL, "Invalid iterator comparison. %s", message);
 1707|      0|    }
 1708|      0|  };
 1709|       |
 1710|      0|  const bool a_is_default = slot_a == DefaultIterSlot();
 1711|      0|  const bool b_is_default = slot_b == DefaultIterSlot();
 1712|      0|  if (a_is_default && b_is_default) return;
  ------------------
  |  Branch (1712:7): [True: 0, False: 0]
  |  Branch (1712:23): [True: 0, False: 0]
  ------------------
 1713|      0|  fail_if(a_is_default != b_is_default,
 1714|      0|          "Comparing default-constructed hashtable iterator with a "
 1715|      0|          "non-default-constructed hashtable iterator.");
 1716|       |
 1717|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1717:7): [Folded, False: 0]
  ------------------
 1718|      0|    if (ABSL_PREDICT_TRUE(generation_ptr_a == generation_ptr_b)) return;
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1719|      0|    const bool a_is_empty = IsEmptyGeneration(generation_ptr_a);
 1720|      0|    const bool b_is_empty = IsEmptyGeneration(generation_ptr_b);
 1721|      0|    fail_if(a_is_empty != b_is_empty,
 1722|      0|            "Comparing an iterator from an empty hashtable with an iterator "
 1723|      0|            "from a non-empty hashtable.");
 1724|      0|    fail_if(a_is_empty && b_is_empty,
  ------------------
  |  Branch (1724:13): [True: 0, False: 0]
  |  Branch (1724:27): [True: 0, False: 0]
  ------------------
 1725|      0|            "Comparing iterators from different empty hashtables.");
 1726|       |
 1727|      0|    const bool a_is_end = slot_a == nullptr;
 1728|      0|    const bool b_is_end = slot_b == nullptr;
 1729|      0|    fail_if(a_is_end || b_is_end,
  ------------------
  |  Branch (1729:13): [True: 0, False: 0]
  |  Branch (1729:25): [True: 0, False: 0]
  ------------------
 1730|      0|            "Comparing iterator with an end() iterator from a different "
 1731|      0|            "hashtable.");
 1732|      0|    fail_if(true, "Comparing non-end() iterators from different hashtables.");
 1733|      0|  } else {
 1734|      0|    ABSL_HARDENING_ASSERT_SLOW(
  ------------------
  |  |  188|      0|#define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  131|      0|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define ABSL_INTERNAL_UNEVALUATED(expr) (decltype((void)(expr))())
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1735|      0|        AreItersFromSameContainer(ctrl_a, ctrl_b, slot_a, slot_b) &&
 1736|      0|        "Invalid iterator comparison. The iterators may be from different "
 1737|      0|        "containers or the container might have rehashed or moved. Consider "
 1738|      0|        "running with --config=asan to diagnose issues.");
 1739|      0|  }
 1740|      0|}
_ZN4absl12lts_2026081718container_internal8probe_h1ENS1_13ProbeCapacityEm:
 1800|    822|inline probe_seq<Group::kWidth> probe_h1(ProbeCapacity capacity, size_t h1) {
 1801|    822|  return probe_seq<Group::kWidth>(capacity, h1);
 1802|    822|}
_ZN4absl12lts_2026081718container_internal5probeENS1_13ProbeCapacityEm:
 1803|    812|inline probe_seq<Group::kWidth> probe(ProbeCapacity capacity, size_t hash) {
 1804|    812|  return probe_h1(capacity, H1(hash));
 1805|    812|}
_ZNK4absl12lts_2026081718container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE9ToRawDataEv:
  537|     15|  IntType ToRawData() const { return capacity_data_; }
_ZNK4absl12lts_2026081718container_internal19MaybeInitializedPtrINS1_6ctrl_tEE3getEv:
 1237|  4.72k|  T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
  ------------------
  |  |  484|  4.72k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
_ZNK4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE4sizeEv:
  701|     14|  size_t size() const { return static_cast<size_t>(data_ >> kSizeShift); }
_ZN4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE12ToPublicSeedEm:
  792|  1.25k|  static constexpr uint64_t ToPublicSeed(uint64_t seed) {
  793|       |    // In kCapacityByLog mode, we shift public seed to the left to keep bits of
  794|       |    // the seed in the original place. It allows us to use single instruction to
  795|       |    // access the seed (e.g., `andl $0x7c0, %r8d`).
  796|  1.25k|    return seed << kCapacityBitStoredInDataCount;
  797|  1.25k|  }
_ZNK4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE4seedEv:
  724|  1.25k|  PerTableSeed seed() const {
  725|  1.25k|    return PerTableSeed(ToPublicSeed(data_ & kSeedMask));
  726|  1.25k|  }
_ZNK4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8capacityEv:
  692|  8.07k|  HashtableCapacity capacity() const {
  693|  8.07k|    return HashtableCapacity::FromRawData(capacity_internal_);
  694|  8.07k|  }
_ZN4absl12lts_2026081718container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE11FromRawDataEm:
  532|  8.07k|  static HashtableCapacityImpl FromRawData(uint64_t capacity) {
  533|  8.07k|    auto cap = HashtableCapacityImpl(uninitialized_tag_t{});
  534|  8.07k|    cap.capacity_data_ = static_cast<IntType>(capacity);
  535|  8.07k|    return cap;
  536|  8.07k|  }
_ZNK4absl12lts_2026081718container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE8is_smallEv:
  557|    818|  constexpr bool is_small() const {
  558|       |    // Small tables have capacity 0 or 1. This expression is valid for both
  559|       |    // capacity storage modes.
  560|       |    // Comparing capacity_data_ directly leads to a better generated code.
  561|       |    // One byte comparison is used before computing the capacity in order to
  562|       |    // detect small tables faster for critical path.
  563|    818|    static_assert(kMaxSmallCapacity == 1);
  564|    818|    return capacity_data_ <= 1;
  565|    818|  }
_ZNK4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8is_smallEv:
  695|    818|  bool is_small() const { return capacity().is_small(); }
_ZN4absl12lts_2026081718container_internal12CommonFields13CreateDefaultILb0EEES2_v:
 1312|      4|  static CommonFields CreateDefault() {
 1313|      4|    return kSooEnabled ? CommonFields{soo_tag_t{}}
  ------------------
  |  Branch (1313:12): [Folded, False: 4]
  ------------------
 1314|      4|                       : CommonFields{non_soo_tag_t{}};
 1315|      4|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE19get_destroy_slot_fnEv:
 3922|      3|  static constexpr DestroySlotFn get_destroy_slot_fn() {
 3923|      3|    return PolicyTraits::template destroy_is_trivial<Alloc>()
  ------------------
  |  Branch (3923:12): [True: 3, Folded]
  ------------------
 3924|      3|               ? nullptr
 3925|      3|               : &raw_hash_set::destroy_slot_fn_impl;
 3926|      3|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6commonEv:
 3838|  1.82k|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE15DefaultCapacityEv:
 2290|      2|  constexpr static size_t DefaultCapacity() {
 2291|      2|    return SooEnabled() ? SooCapacity() : 0;
  ------------------
  |  Branch (2291:12): [Folded, False: 2]
  ------------------
 2292|      2|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8capacityEv:
 2786|    299|  size_t capacity() const {
 2787|    299|    const size_t cap = common().capacity();
 2788|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2789|    299|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2790|    299|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2791|    299|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2792|    299|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  272|    299|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (272:44): [True: 299, False: 0]
  |  |  |  Branch (272:44): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2793|    299|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  272|    299|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2794|    299|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  272|    299|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2795|    299|    return cap;
 2796|    299|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6commonEv:
 3837|  1.21k|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7to_slotEPv:
 3519|    603|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3520|    603|    return static_cast<slot_type*>(buf);
 3521|    603|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE14char_alloc_refEv:
 3893|    301|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026081718container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEC2ENS1_19uninitialized_tag_tE:
  520|  8.07k|  explicit HashtableCapacityImpl(uninitialized_tag_t) {}
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEEC2Ev:
 2534|      1|      std::is_nothrow_default_constructible_v<allocator_type>) {}
_ZN4absl12lts_2026081718container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEC2Em:
  522|     15|      : capacity_data_(static_cast<IntType>(
  523|     15|            StorageMode == kCapacityByValue ? capacity
  ------------------
  |  Branch (523:13): [Folded, False: 15]
  ------------------
  524|     15|                                            : TrailingZeros(capacity + 1))) {
  525|       |    ABSL_SWISSTABLE_ASSERT(capacity == 0 || IsValidCapacity(capacity));
  ------------------
  |  |  257|     15|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  526|     15|  }
_ZN4absl12lts_2026081718container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EEC2ENS1_21HashtableCapacityImplILS3_1EEENS1_19no_seed_empty_tag_tE:
  685|      4|      : capacity_internal_(capacity.ToRawData()), data_(0) {}
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE15unchecked_derefENSA_8iteratorE:
 3820|    256|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8iterator15unchecked_derefEv:
 2466|    512|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE22find_or_prepare_insertINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEENS4_4pairIPNS1_13map_slot_typeIS8_hEEbEERKT_:
 3777|    256|  std::pair<slot_type*, bool> find_or_prepare_insert(const K& key) {
 3778|    256|    AssertOnFind(key);
 3779|    256|    return is_small() ? find_or_prepare_insert_small(key)
  ------------------
  |  Branch (3779:12): [True: 2, False: 254]
  ------------------
 3780|    256|                      : find_or_prepare_insert_large(key);
 3781|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE12AssertOnFindINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEvRKT_:
 3725|    256|  void AssertOnFind([[maybe_unused]] const K& key) {
 3726|    256|    AssertHashEqConsistent(key);
 3727|    256|    AssertNotDebugCapacity();
 3728|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE22AssertHashEqConsistentINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEvRKT_:
 3736|    256|  void AssertHashEqConsistent(const K& key) {
 3737|    256|#ifdef NDEBUG
 3738|    256|    return;
 3739|      0|#endif
 3740|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3741|      0|    if (std::is_same_v<hasher, absl::container_internal::StringHash> &&
  ------------------
  |  Branch (3741:9): [True: 0, Folded]
  ------------------
 3742|      0|        std::is_same_v<key_equal, absl::container_internal::StringEq>) {
  ------------------
  |  Branch (3742:9): [True: 0, Folded]
  ------------------
 3743|      0|      return;
 3744|      0|    }
 3745|      0|    if (std::is_scalar_v<key_type> &&
  ------------------
  |  Branch (3745:9): [Folded, False: 0]
  ------------------
 3746|      0|        std::is_same_v<hasher, absl::Hash<key_type>> &&
  ------------------
  |  Branch (3746:9): [Folded, False: 0]
  ------------------
 3747|      0|        std::is_same_v<key_equal, std::equal_to<key_type>>) {
  ------------------
  |  Branch (3747:9): [Folded, False: 0]
  ------------------
 3748|      0|      return;
 3749|      0|    }
 3750|      0|    if (empty()) return;
  ------------------
  |  Branch (3750:9): [True: 0, False: 0]
  ------------------
 3751|       |
 3752|      0|    const size_t hash_of_arg = hash_of(key);
 3753|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3754|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3755|      0|      if (!is_key_equal) return;
 3756|       |
 3757|      0|      [[maybe_unused]] const bool is_hash_equal =
 3758|      0|          hash_of_arg == hash_of(to_slot(slot));
 3759|      0|      assert((!is_key_equal || is_hash_equal) &&
 3760|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3761|      0|             "hash/eq functors are inconsistent.");
 3762|      0|    };
 3763|       |
 3764|      0|    if (is_small()) {
  ------------------
  |  Branch (3764:9): [True: 0, False: 0]
  ------------------
 3765|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3766|      0|      return;
 3767|      0|    }
 3768|       |    // We only do validation for small tables so that it's constant time.
 3769|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3769:9): [True: 0, False: 0]
  ------------------
 3770|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3771|      0|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE22AssertNotDebugCapacityEv:
 3731|    770|  void AssertNotDebugCapacity() const { common().AssertNotDebugCapacity(); }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE6commonEv:
 3838|  3.51k|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8is_smallEv:
 2312|    512|  bool is_small() const { return common().is_small(); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE28find_or_prepare_insert_smallINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEENS4_4pairIPNS1_13map_slot_typeIS8_hEEbEERKT_:
 3660|      2|  find_or_prepare_insert_small(const K& key) {
 3661|      2|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  257|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3662|       |    if constexpr (SooEnabled()) {
 3663|       |      return find_or_prepare_insert_soo(key);
 3664|       |    }
 3665|      2|    if (!empty()) {
  ------------------
  |  Branch (3665:9): [True: 1, False: 1]
  ------------------
 3666|      1|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3666:11): [True: 0, False: 1]
  ------------------
 3667|      0|        return {single_slot(), false};
 3668|      0|      }
 3669|      1|    }
 3670|      2|    return {to_slot(PrepareInsertSmallNonSoo(
 3671|      2|                common(), GetPolicyFunctions(),
 3672|      2|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3673|      2|            true};
 3674|      2|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE5emptyEv:
 2778|      2|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE4sizeEv:
 2779|      2|  size_t size() const {
 2780|      2|    AssertNotDebugCapacity();
 2781|      2|    const size_t size = common().size();
 2782|      2|    [[maybe_unused]] const size_t kMaxValidSize = MaxValidSize();
 2783|      2|    ABSL_ASSUME(size <= kMaxValidSize);
  ------------------
  |  |  272|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2784|      2|    return size;
 2785|      2|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8equal_toINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEbRKT_PNS1_13map_slot_typeIS8_hEE:
 3502|     12|                                             slot_type* slot) const {
 3503|     12|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3504|     12|                               PolicyTraits::element(slot));
 3505|     12|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE6eq_refEv:
 3892|    268|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE11single_slotEv:
 3862|      1|  slot_type* single_slot() {
 3863|      1|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  257|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3864|      1|    return SooEnabled()
  ------------------
  |  Branch (3864:12): [Folded, False: 1]
  ------------------
 3865|      1|               ? soo_slot()
 3866|      1|               : to_slot(common().slot_array(/*capacity=*/1));
 3867|      1|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE7to_slotEPv:
 3519|  1.02k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3520|  1.02k|    return static_cast<slot_type*>(buf);
 3521|  1.02k|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE6commonEv:
 3837|  2.48k|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE18GetPolicyFunctionsEv:
 3988|    256|  static const PolicyFunctions& GetPolicyFunctions() {
 3989|    256|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3990|    256|                  "Slot size is too large. Use std::unique_ptr for value type "
 3991|    256|                  "or use absl::node_hash_{map,set}.");
 3992|    256|    static_assert(alignof(slot_type) <=
 3993|    256|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3994|    256|    static_assert(sizeof(key_type) <=
 3995|    256|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3996|    256|    static_assert(sizeof(value_type) <=
 3997|    256|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3998|    256|    static constexpr size_t kBackingArrayAlignment =
 3999|    256|        BackingArrayAlignment(alignof(slot_type));
 4000|    256|    static constexpr PolicyFunctions value = {
 4001|    256|        static_cast<uint32_t>(sizeof(key_type)),
 4002|    256|        static_cast<uint32_t>(sizeof(value_type)),
 4003|    256|        static_cast<uint32_t>(sizeof(slot_type)),
 4004|    256|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 4005|    256|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 4006|       |        // TODO(b/328722020): try to type erase
 4007|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 4008|    256|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (4008:9): [True: 0, Folded]
  ------------------
 4009|    256|                                : &raw_hash_set::get_hash_ref_fn,
 4010|    256|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 4011|    256|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (4011:9): [True: 0, Folded]
  ------------------
 4012|    256|            ? TransferNRelocatable<sizeof(slot_type)>
 4013|    256|            : &raw_hash_set::transfer_n_slots_fn,
 4014|    256|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (4014:9): [True: 0, Folded]
  ------------------
 4015|    256|                               : &raw_hash_set::get_char_alloc_ref_fn,
 4016|    256|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 4017|    256|        get_dealloc_backing_array_fn(),
 4018|    256|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 4019|    256|    return value;
 4020|    256|  }
_ZN4absl12lts_2026081718container_internal20TransferNRelocatableILm24EEEvPvS3_S3_m:
 2151|      6|                                                  size_t count) {
 2152|       |  // TODO(b/382423690): Experiment with making specialization for power of 2 and
 2153|       |  // non power of 2. This would require passing the size of the slot.
 2154|      6|  memcpy(dst, src, SizeOfSlot * count);
 2155|      6|}
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSG_PFvSG_hmmE:
 3935|      5|                                    size_t source_offset, size_t h1)) {
 3936|      5|    const size_t new_capacity = common.capacity();
 3937|      5|    ABSL_ASSUME(new_capacity > kMaxSmallCapacity);
  ------------------
  |  |  272|      5|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3938|      5|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3939|      5|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  272|      5|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3940|      5|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  272|      5|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3941|       |
 3942|      5|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3943|      5|    slot_type* old_slots_ptr = to_slot(old_slots);
 3944|      5|    ctrl_t* new_ctrl = common.control();
 3945|      5|    slot_type* new_slots = set->slot_array(new_capacity);
 3946|       |
 3947|     36|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3947:34): [True: 31, False: 5]
  ------------------
 3948|     31|         group_index += Group::kWidth) {
 3949|     31|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3950|     31|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3951|     31|                  Group::kWidth);
 3952|     31|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3953|     31|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3954|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3955|       |      // We will share a lot of code in expense of one function call per group.
 3956|    442|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3956:38): [True: 442, False: 31]
  ------------------
 3957|    442|        size_t old_index = group_index + in_fixed_group_index;
 3958|    442|        slot_type* old_slot = old_slots_ptr + old_index;
 3959|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3960|       |        // only one new bit of h1.
 3961|    442|        size_t hash = set->hash_of(old_slot);
 3962|    442|        size_t h1 = H1(hash);
 3963|    442|        h2_t h2 = H2(hash);
 3964|    442|        size_t new_index = TryFindNewIndexWithoutProbing(
 3965|    442|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3966|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3967|       |        // till and included the old_index.
 3968|    442|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  190|    442|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 3, False: 439]
  |  |  |  Branch (190:49): [Folded, False: 442]
  |  |  |  Branch (190:58): [True: 3, False: 439]
  |  |  ------------------
  ------------------
 3969|      3|          encode_probed_element(probed_storage, h2, old_index, h1);
 3970|      3|          continue;
 3971|      3|        }
 3972|    439|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  257|    439|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3973|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  257|    439|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3974|    439|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3975|    439|        auto* new_slot = new_slots + new_index;
 3976|    439|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3977|    439|        set->transfer(new_slot, old_slot);
 3978|    439|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3979|    439|      }
 3980|     31|    }
 3981|      5|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE10slot_arrayEm:
 3849|      5|  slot_type* slot_array(size_t capacity) const {
 3850|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  257|      5|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3851|      5|    return static_cast<slot_type*>(common().slot_array(capacity));
 3852|      5|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE7hash_ofEPNS1_13map_slot_typeIS8_hEE:
 3511|    442|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3512|    442|    return PolicyTraits::apply(
 3513|    442|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3514|    442|        PolicyTraits::element(slot));
 3515|    442|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8hash_refEv:
 3890|    952|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026081718container_internal29TryFindNewIndexWithoutProbingIvEEmmmmPNS1_6ctrl_tEm:
 1827|    442|                                            size_t new_capacity) {
 1828|    442|  size_t index_diff = old_index - h1;
 1829|       |  // The first probe group starts with h1 & capacity.
 1830|       |  // All following groups start at (h1 + Group::kWidth * K) & capacity.
 1831|       |  // We can find an index within the floating group as index_diff modulo
 1832|       |  // Group::kWidth.
 1833|       |  // Both old and new capacity are larger than Group::kWidth so we can avoid
 1834|       |  // computing `& capacity`.
 1835|    442|  size_t in_floating_group_index = index_diff & (Group::kWidth - 1);
 1836|       |  // By subtracting we will get the difference between the first probe group
 1837|       |  // and the probe group corresponding to old_index.
 1838|    442|  index_diff -= in_floating_group_index;
 1839|    442|  if (ABSL_PREDICT_TRUE((index_diff & old_capacity) == 0)) {
  ------------------
  |  |  191|    442|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 431, False: 11]
  |  |  |  Branch (191:48): [Folded, False: 442]
  |  |  |  Branch (191:57): [True: 431, False: 11]
  |  |  ------------------
  ------------------
 1840|    431|    size_t new_index = (h1 + in_floating_group_index) & new_capacity;
 1841|    431|    ABSL_ASSUME(new_index != kProbedElementIndexSentinel);
  ------------------
  |  |  272|    431|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1842|    431|    return new_index;
 1843|    431|  }
 1844|     11|  ABSL_SWISSTABLE_ASSERT(((old_index - h1) & old_capacity) >= Group::kWidth);
  ------------------
  |  |  257|     11|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1845|       |  // Try to insert element into the first probe group.
 1846|       |  // new_ctrl is not yet fully initialized so we can't use regular search via
 1847|       |  // find_first_non_full.
 1848|       |
 1849|       |  // We can search in the first probe group only if it is located in already
 1850|       |  // initialized part of the table.
 1851|     11|  if (ABSL_PREDICT_FALSE((h1 & old_capacity) >= old_index)) {
  ------------------
  |  |  190|     11|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 3, False: 8]
  |  |  |  Branch (190:49): [Folded, False: 11]
  |  |  |  Branch (190:58): [True: 3, False: 8]
  |  |  ------------------
  ------------------
 1852|      3|    return kProbedElementIndexSentinel;
 1853|      3|  }
 1854|      8|  size_t offset = h1 & new_capacity;
 1855|      8|  Group new_g(new_ctrl + offset);
 1856|      8|  if (auto mask = new_g.MaskNonFull(); ABSL_PREDICT_TRUE(mask)) {
  ------------------
  |  |  191|      8|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 8, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 8]
  |  |  |  Branch (191:57): [True: 8, False: 0]
  |  |  ------------------
  ------------------
 1857|      8|    size_t result = offset + mask.LowestBitSet();
 1858|      8|    ABSL_ASSUME(result != kProbedElementIndexSentinel);
  ------------------
  |  |  272|      8|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1859|      8|    return result;
 1860|      8|  }
 1861|      0|  return kProbedElementIndexSentinel;
 1862|      8|}
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8transferEPNS1_13map_slot_typeIS8_hEESD_:
 3377|    439|  void transfer(slot_type* to, slot_type* from) {
 3378|    439|    common().RunWithReentrancyGuard([&] {
 3379|    439|      allocator_type alloc(char_alloc_ref());
 3380|    439|      PolicyTraits::transfer(&alloc, to, from);
 3381|    439|    });
 3382|    439|  }
_ZN4absl12lts_2026081718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEhEEJEE8transferEPNS1_13map_slot_typeISA_hEESF_EUlvE_EEvT_:
 1486|    439|  void RunWithReentrancyGuard(F f) {
 1487|    439|#ifdef NDEBUG
 1488|    439|    f();
 1489|    439|    return;
 1490|      0|#endif
 1491|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1492|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1493|      0|    f();
 1494|      0|    set_capacity(cap);
 1495|      0|  }
_ZZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8transferEPNS1_13map_slot_typeIS8_hEESD_ENKUlvE_clEv:
 3378|    439|    common().RunWithReentrancyGuard([&] {
 3379|    439|      allocator_type alloc(char_alloc_ref());
 3380|    439|      PolicyTraits::transfer(&alloc, to, from);
 3381|    439|    });
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE14char_alloc_refEv:
 3893|    696|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8hash_refEv:
 3889|      3|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE28find_or_prepare_insert_largeINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEENS4_4pairIPNS1_13map_slot_typeIS8_hEEbEERKT_:
 3677|    254|  std::pair<slot_type*, bool> find_or_prepare_insert_large(const K& key) {
 3678|    254|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  257|    254|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3679|    254|    prefetch_heap_block();
 3680|    254|    const size_t cap = capacity();
 3681|    254|    ABSL_ASSUME(cap > kMaxSmallCapacity);
  ------------------
  |  |  272|    254|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3682|    254|    const size_t hash = hash_of(key);
 3683|    254|    auto seq = probe(ProbeCapacity{cap}, hash);
 3684|    254|    const h2_t h2 = H2(hash);
 3685|    254|    const ctrl_t* ctrl = control();
 3686|    254|    slot_type* slot_array = to_slot(common().slot_array(cap));
 3687|    275|    while (true) {
  ------------------
  |  Branch (3687:12): [True: 275, Folded]
  ------------------
 3688|    275|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3689|    275|      absl::PrefetchToLocalCache(slot_array + seq.offset());
 3690|    275|#endif
 3691|    275|      Group g{ctrl + seq.offset()};
 3692|    275|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3692:23): [True: 11, False: 275]
  ------------------
 3693|     11|        slot_type* slot = slot_array + seq.offset(i);
 3694|     11|        if (ABSL_PREDICT_TRUE(equal_to(key, slot))) {
  ------------------
  |  |  191|     11|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 11]
  |  |  |  Branch (191:48): [Folded, False: 11]
  |  |  |  Branch (191:57): [True: 0, False: 11]
  |  |  ------------------
  ------------------
 3695|      0|          return {slot, false};
 3696|      0|        }
 3697|     11|      }
 3698|    275|      auto mask_empty = g.MaskEmpty();
 3699|    275|      if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|    275|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 254, False: 21]
  |  |  |  Branch (191:48): [Folded, False: 275]
  |  |  |  Branch (191:57): [True: 254, False: 21]
  |  |  ------------------
  ------------------
 3700|    254|        size_t target_group_offset = seq.offset();
 3701|    254|        void* slot =
 3702|    254|            SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3702:13): [Folded, False: 254]
  ------------------
 3703|    254|                ? PrepareInsertLargeGenerationsEnabled(
 3704|      0|                      common(), GetPolicyFunctions(), hash, mask_empty,
 3705|      0|                      FindInfo{target_group_offset, seq.index()},
 3706|      0|                      HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3707|    254|                : PrepareInsertLarge(
 3708|    254|                      common(), GetPolicyFunctions(), hash, mask_empty,
 3709|    254|                      FindInfo{target_group_offset, seq.index()});
 3710|    254|        return {to_slot(slot), true};
 3711|    254|      }
 3712|     21|      seq.next();
 3713|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  257|     21|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3714|     21|    }
 3715|    254|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE19prefetch_heap_blockEv:
 3830|    510|  void prefetch_heap_block() const {
 3831|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  257|    510|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3832|    510|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3833|    510|    __builtin_prefetch(control(), 0, 1);
 3834|    510|#endif
 3835|    510|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8capacityEv:
 2786|    255|  size_t capacity() const {
 2787|    255|    const size_t cap = common().capacity();
 2788|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2789|    255|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2790|    255|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2791|    255|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2792|    255|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  272|    256|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (272:44): [True: 254, False: 1]
  |  |  |  Branch (272:44): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 2793|    255|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  272|    255|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2794|    255|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  272|    255|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2795|    255|    return cap;
 2796|    255|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE7hash_ofINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEmRKT_:
 3507|    254|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3508|    254|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3509|    254|                                               common().seed().seed()}(key);
 3510|    254|  }
_ZN4absl12lts_2026081718container_internal9probe_seqILm16EEC2ENS1_13ProbeCapacityEm:
 1779|    822|      : capacity_(capacity.capacity), offset_(hash & capacity_) {}
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE7controlEv:
 3845|  1.02k|  ctrl_t* control() const {
 3846|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  257|  1.02k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3847|  1.02k|    return common().control();
 3848|  1.02k|  }
_ZNK4absl12lts_2026081718container_internal9probe_seqILm16EE6offsetEv:
 1782|  2.23k|  size_t offset() const { return offset_; }
_ZNK4absl12lts_2026081718container_internal9probe_seqILm16EE6offsetEm:
 1783|    284|  size_t offset(size_t i) const { return (offset_ + i) & capacity_; }
_ZNK4absl12lts_2026081718container_internal9probe_seqILm16EE5indexEv:
 1791|    557|  size_t index() const { return index_; }
_ZN4absl12lts_2026081718container_internal9probe_seqILm16EE4nextEv:
 1785|     21|  void next() {
 1786|     21|    index_ += Width;
 1787|     21|    offset_ += index_;
 1788|     21|    offset_ &= capacity_;
 1789|     21|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEENSF_IJEEEEEEvPNS1_13map_slot_typeIS8_hEEDpOT_:
 3792|    256|  void emplace_at(slot_type* slot, Args&&... args) {
 3793|    256|    construct(slot, std::forward<Args>(args)...);
 3794|       |
 3795|       |    // When is_small, find calls find_small and if size is 0, then it will
 3796|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3797|       |    assert((is_small() ||
 3798|    256|            PolicyTraits::apply(FindElement{*this}, PolicyTraits::element(slot))
 3799|    256|                    .slot() == slot) &&
 3800|    256|           "constructed value does not match the lookup key");
 3801|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEENSF_IJEEEEEEvPNS1_13map_slot_typeIS8_hEEDpOT_:
 3365|    256|  void construct(slot_type* slot, Args&&... args) {
 3366|    256|    common().RunWithReentrancyGuard([&] {
 3367|    256|      allocator_type alloc(char_alloc_ref());
 3368|    256|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3369|    256|    });
 3370|    256|  }
_ZN4absl12lts_2026081718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEhEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKNS6_12basic_stringIcS9_NS6_9allocatorIcEEEEEEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_hEEDpOT_EUlvE_EEvT_:
 1486|    256|  void RunWithReentrancyGuard(F f) {
 1487|    256|#ifdef NDEBUG
 1488|    256|    f();
 1489|    256|    return;
 1490|      0|#endif
 1491|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1492|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1493|      0|    f();
 1494|      0|    set_capacity(cap);
 1495|      0|  }
_ZZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEENSF_IJEEEEEEvPNS1_13map_slot_typeIS8_hEEDpOT_ENKUlvE_clEv:
 3366|    256|    common().RunWithReentrancyGuard([&] {
 3367|    256|      allocator_type alloc(char_alloc_ref());
 3368|    256|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3369|    256|    });
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE29non_iterable_iterator_at_slotEPNS1_13map_slot_typeIS8_hEE:
 3806|    256|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3807|    256|    return {InsertIteratorControl(), slot, common().generation_ptr()};
 3808|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIS8_hEEPKh:
 2434|    512|        : HashSetIteratorGenerationInfo(generation_ptr),
 2435|    512|          ctrl_(ctrl),
 2436|    512|          slot_(slot) {
 2437|       |      // This assumption helps the compiler know that any non-end iterator is
 2438|       |      // not equal to any end iterator.
 2439|    512|      ABSL_ASSUME(slot != nullptr);
  ------------------
  |  |  272|    512|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2440|    512|    }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEEC2EOSA_:
 2695|      1|        settings_(PolicyTraits::transfer_uses_memcpy() || !that.is_full_soo()
  ------------------
  |  Branch (2695:19): [True: 1, Folded]
  |  Branch (2695:59): [True: 0, False: 0]
  ------------------
 2696|      1|                      ? std::move(that.common())
 2697|      1|                      : CommonFields{full_soo_tag_t{},
 2698|      0|                                     that.common().soo_has_tried_sampling()},
 2699|      1|                  that.hash_ref(), that.eq_ref(), that.char_alloc_ref()) {
 2700|      1|    if (!PolicyTraits::transfer_uses_memcpy() && that.is_full_soo()) {
  ------------------
  |  Branch (2700:9): [Folded, False: 1]
  |  Branch (2700:50): [True: 0, False: 0]
  ------------------
 2701|      0|      transfer(soo_slot(), that.soo_slot());
 2702|      0|    }
 2703|      1|    that.common() = CommonFields::CreateDefault<SooEnabled()>();
 2704|      1|    annotate_for_bug_detection_on_move(that);
 2705|      1|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE6eq_refEv:
 3891|      1|  key_equal& eq_ref() { return settings_.template get<2>(); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE34annotate_for_bug_detection_on_moveERSA_:
 3557|      1|  void annotate_for_bug_detection_on_move([[maybe_unused]] raw_hash_set& that) {
 3558|       |    // We only enable moved-from validation when generations are enabled (rather
 3559|       |    // than using NDEBUG) to avoid issues in which NDEBUG is enabled in some
 3560|       |    // translation units but not in others.
 3561|      1|    if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3561:9): [Folded, False: 1]
  ------------------
 3562|      0|      that.common().set_capacity(this == &that
  ------------------
  |  Branch (3562:34): [True: 0, False: 0]
  ------------------
 3563|      0|                                     ? HashtableCapacity::CreateSelfMovedFrom()
 3564|      0|                                     : HashtableCapacity::CreateMovedFrom());
 3565|      0|    }
 3566|      1|    if (!SwisstableGenerationsEnabled() ||
  ------------------
  |  Branch (3566:9): [True: 1, Folded]
  |  Branch (3566:9): [True: 1, Folded]
  ------------------
 3567|      0|        !maybe_invalid_capacity().IsValid() ||
  ------------------
  |  Branch (3567:9): [True: 0, False: 0]
  ------------------
 3568|      1|        capacity() == DefaultCapacity()) {
  ------------------
  |  Branch (3568:9): [True: 0, False: 0]
  ------------------
 3569|      1|      return;
 3570|      1|    }
 3571|      0|    common().increment_generation();
 3572|      0|    if (!empty() && common().should_rehash_for_bug_detection_on_move()) {
  ------------------
  |  Branch (3572:9): [True: 0, False: 0]
  |  Branch (3572:21): [True: 0, False: 0]
  ------------------
 3573|      0|      ResizeAllocatedTableWithSeedChange(common(), GetPolicyFunctions(),
 3574|      0|                                         capacity());
 3575|      0|    }
 3576|      0|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEED2Ev:
 2746|      1|  ~raw_hash_set() {
 2747|      1|    destructor_impl();
 2748|       |    if constexpr (SwisstableGenerationsOrDebugEnabled()) {
 2749|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 2750|       |    }
 2751|      1|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE15destructor_implEv:
 3457|      1|  void destructor_impl() {
 3458|      1|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3458:9): [Folded, False: 1]
  |  Branch (3458:9): [Folded, False: 1]
  ------------------
 3459|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (3459:9): [True: 0, False: 0]
  ------------------
 3460|      0|      return;
 3461|      0|    }
 3462|       |    if constexpr (SooEnabled()) {
 3463|       |      if (is_small() &&
 3464|       |          (PolicyTraits::template destroy_is_trivial<Alloc>() || empty())) {
 3465|       |        return;
 3466|       |      }
 3467|       |      DestructSoo(common(), sizeof(slot_type), alignof(slot_type),
 3468|       |                  get_destroy_slot_fn(), get_dealloc_backing_array_fn(),
 3469|       |                  &char_alloc_ref());
 3470|      1|    } else {
 3471|      1|      if (capacity() == 0) return;
  ------------------
  |  Branch (3471:11): [True: 1, False: 0]
  ------------------
 3472|      0|      DestructNonSoo(common(), sizeof(slot_type), alignof(slot_type),
 3473|      0|                     get_destroy_slot_fn(), get_dealloc_backing_array_fn(),
 3474|      0|                     &char_alloc_ref());
 3475|      0|    }
 3476|      1|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEEC2Ev:
 2534|      2|      std::is_nothrow_default_constructible_v<allocator_type>) {}
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE4findIS8_EENSA_14const_iteratorERKT_:
 3240|      4|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3241|      4|    return const_cast<raw_hash_set*>(this)->find(key);
 3242|      4|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE4findIS8_EENSA_8iteratorERKT_:
 3225|      4|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3226|      4|    AssertOnFind(key);
 3227|      4|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (3227:9): [True: 0, False: 4]
  ------------------
 3228|      4|    prefetch_heap_block();
 3229|      4|    return find_large(key);
 3230|      4|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE12AssertOnFindIS8_EEvRKT_:
 3725|      4|  void AssertOnFind([[maybe_unused]] const K& key) {
 3726|      4|    AssertHashEqConsistent(key);
 3727|      4|    AssertNotDebugCapacity();
 3728|      4|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22AssertHashEqConsistentIS8_EEvRKT_:
 3736|      4|  void AssertHashEqConsistent(const K& key) {
 3737|      4|#ifdef NDEBUG
 3738|      4|    return;
 3739|      0|#endif
 3740|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3741|      0|    if (std::is_same_v<hasher, absl::container_internal::StringHash> &&
  ------------------
  |  Branch (3741:9): [True: 0, Folded]
  ------------------
 3742|      0|        std::is_same_v<key_equal, absl::container_internal::StringEq>) {
  ------------------
  |  Branch (3742:9): [True: 0, Folded]
  ------------------
 3743|      0|      return;
 3744|      0|    }
 3745|      0|    if (std::is_scalar_v<key_type> &&
  ------------------
  |  Branch (3745:9): [Folded, False: 0]
  ------------------
 3746|      0|        std::is_same_v<hasher, absl::Hash<key_type>> &&
  ------------------
  |  Branch (3746:9): [Folded, False: 0]
  ------------------
 3747|      0|        std::is_same_v<key_equal, std::equal_to<key_type>>) {
  ------------------
  |  Branch (3747:9): [Folded, False: 0]
  ------------------
 3748|      0|      return;
 3749|      0|    }
 3750|      0|    if (empty()) return;
  ------------------
  |  Branch (3750:9): [True: 0, False: 0]
  ------------------
 3751|       |
 3752|      0|    const size_t hash_of_arg = hash_of(key);
 3753|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3754|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3755|      0|      if (!is_key_equal) return;
 3756|       |
 3757|      0|      [[maybe_unused]] const bool is_hash_equal =
 3758|      0|          hash_of_arg == hash_of(to_slot(slot));
 3759|      0|      assert((!is_key_equal || is_hash_equal) &&
 3760|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3761|      0|             "hash/eq functors are inconsistent.");
 3762|      0|    };
 3763|       |
 3764|      0|    if (is_small()) {
  ------------------
  |  Branch (3764:9): [True: 0, False: 0]
  ------------------
 3765|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3766|      0|      return;
 3767|      0|    }
 3768|       |    // We only do validation for small tables so that it's constant time.
 3769|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3769:9): [True: 0, False: 0]
  ------------------
 3770|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3771|      0|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22AssertNotDebugCapacityEv:
 3731|    309|  void AssertNotDebugCapacity() const { common().AssertNotDebugCapacity(); }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8is_smallEv:
 2312|    303|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5emptyEv:
 2778|      1|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE4sizeEv:
 2779|      1|  size_t size() const {
 2780|      1|    AssertNotDebugCapacity();
 2781|      1|    const size_t size = common().size();
 2782|      1|    [[maybe_unused]] const size_t kMaxValidSize = MaxValidSize();
 2783|      1|    ABSL_ASSUME(size <= kMaxValidSize);
  ------------------
  |  |  272|      1|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2784|      1|    return size;
 2785|      1|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8equal_toIS8_EEbRKT_PNS1_13map_slot_typeIS8_iEE:
 3502|      3|                                             slot_type* slot) const {
 3503|      3|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3504|      3|                               PolicyTraits::element(slot));
 3505|      3|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6eq_refEv:
 3892|     12|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE3endEv:
 2762|      6|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2763|      6|    AssertNotDebugCapacity();
 2764|      6|    return iterator(common().generation_ptr());
 2765|      6|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorC2EPKh:
 2443|      6|        : HashSetIteratorGenerationInfo(generation_ptr), slot_(nullptr) {}
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIS8_iEEPKh:
 2434|    302|        : HashSetIteratorGenerationInfo(generation_ptr),
 2435|    302|          ctrl_(ctrl),
 2436|    302|          slot_(slot) {
 2437|       |      // This assumption helps the compiler know that any non-end iterator is
 2438|       |      // not equal to any end iterator.
 2439|    302|      ABSL_ASSUME(slot != nullptr);
  ------------------
  |  |  272|    302|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2440|    302|    }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE19prefetch_heap_blockEv:
 3830|    302|  void prefetch_heap_block() const {
 3831|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  257|    302|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3832|    302|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3833|    302|    __builtin_prefetch(control(), 0, 1);
 3834|    302|#endif
 3835|    302|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7controlEv:
 3845|    605|  ctrl_t* control() const {
 3846|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  257|    605|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3847|    605|    return common().control();
 3848|    605|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE10find_largeIS8_EENSA_8iteratorERKT_:
 3393|      4|  iterator find_large(const key_arg<K>& key) {
 3394|      4|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  257|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3395|      4|    const size_t cap = common().capacity();
 3396|      4|    ABSL_ASSUME(cap > kMaxSmallCapacity);
  ------------------
  |  |  272|      4|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3397|      4|    const size_t hash = hash_of(key);
 3398|      4|    auto seq = probe(ProbeCapacity{cap}, hash);
 3399|      4|    const h2_t h2 = H2(hash);
 3400|      4|    ctrl_t* ctrl = control();
 3401|      4|    slot_type* slot_array = to_slot(common().slot_array(cap));
 3402|      4|    while (true) {
  ------------------
  |  Branch (3402:12): [True: 4, Folded]
  ------------------
 3403|      4|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3404|      4|      absl::PrefetchToLocalCache(slot_array + seq.offset());
 3405|      4|#endif
 3406|      4|      Group g{ctrl + seq.offset()};
 3407|      4|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3407:23): [True: 3, False: 1]
  ------------------
 3408|      3|        const size_t offset = seq.offset(i);
 3409|      3|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array + offset)))
  ------------------
  |  |  191|      3|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 3, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 3]
  |  |  |  Branch (191:57): [True: 3, False: 0]
  |  |  ------------------
  ------------------
 3410|      3|          return iterator_at_ptr(ctrl + offset, slot_array + offset);
 3411|      3|      }
 3412|      1|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  191|      1|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 1]
  |  |  |  Branch (191:57): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 3413|      0|      seq.next();
 3414|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= cap && "full table!");
  ------------------
  |  |  257|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3415|      0|    }
 3416|      4|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7hash_ofIS8_EEmRKT_:
 3507|      4|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3508|      4|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3509|      4|                                               common().seed().seed()}(key);
 3510|      4|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8hash_refEv:
 3890|    302|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE15iterator_at_ptrEPNS1_6ctrl_tEPv:
 3816|      3|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3817|      3|    return {ctrl, to_slot(slot), common().generation_ptr()};
 3818|      3|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE14const_iteratorC2ENSA_8iteratorE:
 2494|      8|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE3endEv:
 2770|      4|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2771|      4|    return const_cast<raw_hash_set*>(this)->end();
 2772|      4|  }
_ZN4absl12lts_2026081718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE14const_iteratorESD_:
 2508|      4|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2509|      4|      return !(a == b);
 2510|      4|    }
_ZN4absl12lts_2026081718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE14const_iteratorESD_:
 2505|      4|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2506|      4|      return a.inner_ == b.inner_;
 2507|      4|    }
_ZN4absl12lts_2026081718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorESD_:
 2418|     44|    friend bool operator==(const iterator& a, const iterator& b) {
 2419|     44|      AssertIsValidForComparison(a.ctrl_, a.slot_, a.generation(),
 2420|     44|                                 a.generation_ptr());
 2421|     44|      AssertIsValidForComparison(b.ctrl_, b.slot_, b.generation(),
 2422|     44|                                 b.generation_ptr());
 2423|     44|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 2424|     44|                          a.generation_ptr(), b.generation_ptr());
 2425|     44|      return a.unchecked_equals(b);
 2426|     44|    }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator16unchecked_equalsERKSB_:
 2462|     44|    bool unchecked_equals(const iterator& b) const { return slot_ == b.slot(); }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator4slotEv:
 2469|     44|    slot_type* slot() const { return slot_; }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE14const_iteratorptEv:
 2497|      3|    pointer operator->() const { return inner_.operator->(); }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorptEv:
 2397|      3|    pointer operator->() const {
 2398|      3|      assert_is_full("operator->");
 2399|      3|      return &operator*();
 2400|      3|    }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator14assert_is_fullEPKc:
 2445|     84|    void assert_is_full(const char* operation) const {
 2446|     84|      AssertIsFull(ctrl_, slot_, generation(), generation_ptr(), operation);
 2447|     84|    }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratordeEv:
 2391|     42|    reference operator*() const {
 2392|     42|      assert_is_full("operator*()");
 2393|     42|      return unchecked_deref();
 2394|     42|    }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator15unchecked_derefEv:
 2466|     42|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5clearEv:
 2799|      3|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2800|      3|    Clear<SooEnabled()>(common(), GetPolicyFunctions(), get_destroy_slot_fn(),
 2801|      3|                        &char_alloc_ref());
 2802|      3|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE18GetPolicyFunctionsEv:
 3988|    303|  static const PolicyFunctions& GetPolicyFunctions() {
 3989|    303|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3990|    303|                  "Slot size is too large. Use std::unique_ptr for value type "
 3991|    303|                  "or use absl::node_hash_{map,set}.");
 3992|    303|    static_assert(alignof(slot_type) <=
 3993|    303|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3994|    303|    static_assert(sizeof(key_type) <=
 3995|    303|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3996|    303|    static_assert(sizeof(value_type) <=
 3997|    303|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3998|    303|    static constexpr size_t kBackingArrayAlignment =
 3999|    303|        BackingArrayAlignment(alignof(slot_type));
 4000|    303|    static constexpr PolicyFunctions value = {
 4001|    303|        static_cast<uint32_t>(sizeof(key_type)),
 4002|    303|        static_cast<uint32_t>(sizeof(value_type)),
 4003|    303|        static_cast<uint32_t>(sizeof(slot_type)),
 4004|    303|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 4005|    303|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 4006|       |        // TODO(b/328722020): try to type erase
 4007|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 4008|    303|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (4008:9): [True: 0, Folded]
  ------------------
 4009|    303|                                : &raw_hash_set::get_hash_ref_fn,
 4010|    303|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 4011|    303|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (4011:9): [True: 0, Folded]
  ------------------
 4012|    303|            ? TransferNRelocatable<sizeof(slot_type)>
 4013|    303|            : &raw_hash_set::transfer_n_slots_fn,
 4014|    303|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (4014:9): [True: 0, Folded]
  ------------------
 4015|    303|                               : &raw_hash_set::get_char_alloc_ref_fn,
 4016|    303|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 4017|    303|        get_dealloc_backing_array_fn(),
 4018|    303|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 4019|    303|    return value;
 4020|    303|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE10slot_arrayEm:
 3849|      1|  slot_type* slot_array(size_t capacity) const {
 3850|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  257|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3851|      1|    return static_cast<slot_type*>(common().slot_array(capacity));
 3852|      1|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7reserveEm:
 3178|      2|  void reserve(size_t n) {
 3179|      2|    if (ABSL_PREDICT_TRUE(n > DefaultCapacity())) {
  ------------------
  |  |  191|      2|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 2, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 2]
  |  |  |  Branch (191:57): [True: 2, False: 0]
  |  |  ------------------
  ------------------
 3180|      2|      ReserveTableToFitNewSize(common(), GetPolicyFunctions(), n);
 3181|      2|    }
 3182|      2|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7emplaceIJRKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEERiETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENS4_4pairINSA_8iteratorEbEEDpOSK_:
 2960|    298|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2961|    298|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2962|    298|                               std::forward<Args>(args)...);
 2963|    298|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE19EmplaceDecomposableclINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSG_EEENSK_IJRiEEEEEENS4_4pairINSA_8iteratorEbEERKT_DpOT0_:
 3337|    298|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 3338|    298|      auto res = s.find_or_prepare_insert(key);
 3339|    298|      if (res.second) {
  ------------------
  |  Branch (3339:11): [True: 298, False: 0]
  ------------------
 3340|    298|        s.emplace_at(res.first, std::forward<Args>(args)...);
 3341|    298|      }
 3342|    298|      return {s.non_iterable_iterator_at_slot(res.first), res.second};
 3343|    298|    }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22find_or_prepare_insertINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEENS4_4pairIPNS1_13map_slot_typeIS8_iEEbEERKT_:
 3777|    298|  std::pair<slot_type*, bool> find_or_prepare_insert(const K& key) {
 3778|    298|    AssertOnFind(key);
 3779|    298|    return is_small() ? find_or_prepare_insert_small(key)
  ------------------
  |  Branch (3779:12): [True: 0, False: 298]
  ------------------
 3780|    298|                      : find_or_prepare_insert_large(key);
 3781|    298|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE12AssertOnFindINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEvRKT_:
 3725|    298|  void AssertOnFind([[maybe_unused]] const K& key) {
 3726|    298|    AssertHashEqConsistent(key);
 3727|    298|    AssertNotDebugCapacity();
 3728|    298|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22AssertHashEqConsistentINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEvRKT_:
 3736|    298|  void AssertHashEqConsistent(const K& key) {
 3737|    298|#ifdef NDEBUG
 3738|    298|    return;
 3739|      0|#endif
 3740|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3741|      0|    if (std::is_same_v<hasher, absl::container_internal::StringHash> &&
  ------------------
  |  Branch (3741:9): [True: 0, Folded]
  ------------------
 3742|      0|        std::is_same_v<key_equal, absl::container_internal::StringEq>) {
  ------------------
  |  Branch (3742:9): [True: 0, Folded]
  ------------------
 3743|      0|      return;
 3744|      0|    }
 3745|      0|    if (std::is_scalar_v<key_type> &&
  ------------------
  |  Branch (3745:9): [Folded, False: 0]
  ------------------
 3746|      0|        std::is_same_v<hasher, absl::Hash<key_type>> &&
  ------------------
  |  Branch (3746:9): [Folded, False: 0]
  ------------------
 3747|      0|        std::is_same_v<key_equal, std::equal_to<key_type>>) {
  ------------------
  |  Branch (3747:9): [Folded, False: 0]
  ------------------
 3748|      0|      return;
 3749|      0|    }
 3750|      0|    if (empty()) return;
  ------------------
  |  Branch (3750:9): [True: 0, False: 0]
  ------------------
 3751|       |
 3752|      0|    const size_t hash_of_arg = hash_of(key);
 3753|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3754|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3755|      0|      if (!is_key_equal) return;
 3756|       |
 3757|      0|      [[maybe_unused]] const bool is_hash_equal =
 3758|      0|          hash_of_arg == hash_of(to_slot(slot));
 3759|      0|      assert((!is_key_equal || is_hash_equal) &&
 3760|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3761|      0|             "hash/eq functors are inconsistent.");
 3762|      0|    };
 3763|       |
 3764|      0|    if (is_small()) {
  ------------------
  |  Branch (3764:9): [True: 0, False: 0]
  ------------------
 3765|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3766|      0|      return;
 3767|      0|    }
 3768|       |    // We only do validation for small tables so that it's constant time.
 3769|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3769:9): [True: 0, False: 0]
  ------------------
 3770|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3771|      0|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8equal_toINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEbRKT_PNS1_13map_slot_typeIS8_iEE:
 3502|      9|                                             slot_type* slot) const {
 3503|      9|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3504|      9|                               PolicyTraits::element(slot));
 3505|      9|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE28find_or_prepare_insert_largeINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEENS4_4pairIPNS1_13map_slot_typeIS8_iEEbEERKT_:
 3677|    298|  std::pair<slot_type*, bool> find_or_prepare_insert_large(const K& key) {
 3678|    298|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  257|    298|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3679|    298|    prefetch_heap_block();
 3680|    298|    const size_t cap = capacity();
 3681|    298|    ABSL_ASSUME(cap > kMaxSmallCapacity);
  ------------------
  |  |  272|    298|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3682|    298|    const size_t hash = hash_of(key);
 3683|    298|    auto seq = probe(ProbeCapacity{cap}, hash);
 3684|    298|    const h2_t h2 = H2(hash);
 3685|    298|    const ctrl_t* ctrl = control();
 3686|    298|    slot_type* slot_array = to_slot(common().slot_array(cap));
 3687|    298|    while (true) {
  ------------------
  |  Branch (3687:12): [True: 298, Folded]
  ------------------
 3688|    298|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3689|    298|      absl::PrefetchToLocalCache(slot_array + seq.offset());
 3690|    298|#endif
 3691|    298|      Group g{ctrl + seq.offset()};
 3692|    298|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3692:23): [True: 9, False: 298]
  ------------------
 3693|      9|        slot_type* slot = slot_array + seq.offset(i);
 3694|      9|        if (ABSL_PREDICT_TRUE(equal_to(key, slot))) {
  ------------------
  |  |  191|      9|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 9]
  |  |  |  Branch (191:48): [Folded, False: 9]
  |  |  |  Branch (191:57): [True: 0, False: 9]
  |  |  ------------------
  ------------------
 3695|      0|          return {slot, false};
 3696|      0|        }
 3697|      9|      }
 3698|    298|      auto mask_empty = g.MaskEmpty();
 3699|    298|      if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|    298|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 298, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 298]
  |  |  |  Branch (191:57): [True: 298, False: 0]
  |  |  ------------------
  ------------------
 3700|    298|        size_t target_group_offset = seq.offset();
 3701|    298|        void* slot =
 3702|    298|            SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3702:13): [Folded, False: 298]
  ------------------
 3703|    298|                ? PrepareInsertLargeGenerationsEnabled(
 3704|      0|                      common(), GetPolicyFunctions(), hash, mask_empty,
 3705|      0|                      FindInfo{target_group_offset, seq.index()},
 3706|      0|                      HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3707|    298|                : PrepareInsertLarge(
 3708|    298|                      common(), GetPolicyFunctions(), hash, mask_empty,
 3709|    298|                      FindInfo{target_group_offset, seq.index()});
 3710|    298|        return {to_slot(slot), true};
 3711|    298|      }
 3712|      0|      seq.next();
 3713|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  257|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3714|      0|    }
 3715|    298|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7hash_ofINS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEmRKT_:
 3507|    298|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3508|    298|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3509|    298|                                               common().seed().seed()}(key);
 3510|    298|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEENSF_IJRiEEEEEEvPNS1_13map_slot_typeIS8_iEEDpOT_:
 3792|    298|  void emplace_at(slot_type* slot, Args&&... args) {
 3793|    298|    construct(slot, std::forward<Args>(args)...);
 3794|       |
 3795|       |    // When is_small, find calls find_small and if size is 0, then it will
 3796|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3797|       |    assert((is_small() ||
 3798|    298|            PolicyTraits::apply(FindElement{*this}, PolicyTraits::element(slot))
 3799|    298|                    .slot() == slot) &&
 3800|    298|           "constructed value does not match the lookup key");
 3801|    298|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEENSF_IJRiEEEEEEvPNS1_13map_slot_typeIS8_iEEDpOT_:
 3365|    298|  void construct(slot_type* slot, Args&&... args) {
 3366|    298|    common().RunWithReentrancyGuard([&] {
 3367|    298|      allocator_type alloc(char_alloc_ref());
 3368|    298|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3369|    298|    });
 3370|    298|  }
_ZN4absl12lts_2026081718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEiEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKNS6_12basic_stringIcS9_NS6_9allocatorIcEEEEEEENSH_IJRiEEEEEEvPNS1_13map_slot_typeISA_iEEDpOT_EUlvE_EEvT_:
 1486|    298|  void RunWithReentrancyGuard(F f) {
 1487|    298|#ifdef NDEBUG
 1488|    298|    f();
 1489|    298|    return;
 1490|      0|#endif
 1491|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1492|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1493|      0|    f();
 1494|      0|    set_capacity(cap);
 1495|      0|  }
_ZZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEEEENSF_IJRiEEEEEEvPNS1_13map_slot_typeIS8_iEEDpOT_ENKUlvE_clEv:
 3366|    298|    common().RunWithReentrancyGuard([&] {
 3367|    298|      allocator_type alloc(char_alloc_ref());
 3368|    298|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3369|    298|    });
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE29non_iterable_iterator_at_slotEPNS1_13map_slot_typeIS8_iEE:
 3806|    298|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3807|    298|    return {InsertIteratorControl(), slot, common().generation_ptr()};
 3808|    298|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE4findIS8_EENSA_14const_iteratorERKT_:
 3240|    256|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3241|    256|    return const_cast<raw_hash_set*>(this)->find(key);
 3242|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE4findIS8_EENSA_8iteratorERKT_:
 3225|    256|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3226|    256|    AssertOnFind(key);
 3227|    256|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (3227:9): [True: 0, False: 256]
  ------------------
 3228|    256|    prefetch_heap_block();
 3229|    256|    return find_large(key);
 3230|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE12AssertOnFindIS8_EEvRKT_:
 3725|    256|  void AssertOnFind([[maybe_unused]] const K& key) {
 3726|    256|    AssertHashEqConsistent(key);
 3727|    256|    AssertNotDebugCapacity();
 3728|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE22AssertHashEqConsistentIS8_EEvRKT_:
 3736|    256|  void AssertHashEqConsistent(const K& key) {
 3737|    256|#ifdef NDEBUG
 3738|    256|    return;
 3739|      0|#endif
 3740|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3741|      0|    if (std::is_same_v<hasher, absl::container_internal::StringHash> &&
  ------------------
  |  Branch (3741:9): [True: 0, Folded]
  ------------------
 3742|      0|        std::is_same_v<key_equal, absl::container_internal::StringEq>) {
  ------------------
  |  Branch (3742:9): [True: 0, Folded]
  ------------------
 3743|      0|      return;
 3744|      0|    }
 3745|      0|    if (std::is_scalar_v<key_type> &&
  ------------------
  |  Branch (3745:9): [Folded, False: 0]
  ------------------
 3746|      0|        std::is_same_v<hasher, absl::Hash<key_type>> &&
  ------------------
  |  Branch (3746:9): [Folded, False: 0]
  ------------------
 3747|      0|        std::is_same_v<key_equal, std::equal_to<key_type>>) {
  ------------------
  |  Branch (3747:9): [Folded, False: 0]
  ------------------
 3748|      0|      return;
 3749|      0|    }
 3750|      0|    if (empty()) return;
  ------------------
  |  Branch (3750:9): [True: 0, False: 0]
  ------------------
 3751|       |
 3752|      0|    const size_t hash_of_arg = hash_of(key);
 3753|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3754|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3755|      0|      if (!is_key_equal) return;
 3756|       |
 3757|      0|      [[maybe_unused]] const bool is_hash_equal =
 3758|      0|          hash_of_arg == hash_of(to_slot(slot));
 3759|      0|      assert((!is_key_equal || is_hash_equal) &&
 3760|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3761|      0|             "hash/eq functors are inconsistent.");
 3762|      0|    };
 3763|       |
 3764|      0|    if (is_small()) {
  ------------------
  |  Branch (3764:9): [True: 0, False: 0]
  ------------------
 3765|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3766|      0|      return;
 3767|      0|    }
 3768|       |    // We only do validation for small tables so that it's constant time.
 3769|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3769:9): [True: 0, False: 0]
  ------------------
 3770|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3771|      0|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8equal_toIS8_EEbRKT_PNS1_13map_slot_typeIS8_hEE:
 3502|    256|                                             slot_type* slot) const {
 3503|    256|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3504|    256|                               PolicyTraits::element(slot));
 3505|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE3endEv:
 2762|    256|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2763|    256|    AssertNotDebugCapacity();
 2764|    256|    return iterator(common().generation_ptr());
 2765|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8iteratorC2EPKh:
 2443|    256|        : HashSetIteratorGenerationInfo(generation_ptr), slot_(nullptr) {}
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE10find_largeIS8_EENSA_8iteratorERKT_:
 3393|    256|  iterator find_large(const key_arg<K>& key) {
 3394|    256|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  257|    256|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3395|    256|    const size_t cap = common().capacity();
 3396|    256|    ABSL_ASSUME(cap > kMaxSmallCapacity);
  ------------------
  |  |  272|    256|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3397|    256|    const size_t hash = hash_of(key);
 3398|    256|    auto seq = probe(ProbeCapacity{cap}, hash);
 3399|    256|    const h2_t h2 = H2(hash);
 3400|    256|    ctrl_t* ctrl = control();
 3401|    256|    slot_type* slot_array = to_slot(common().slot_array(cap));
 3402|    256|    while (true) {
  ------------------
  |  Branch (3402:12): [True: 256, Folded]
  ------------------
 3403|    256|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3404|    256|      absl::PrefetchToLocalCache(slot_array + seq.offset());
 3405|    256|#endif
 3406|    256|      Group g{ctrl + seq.offset()};
 3407|    256|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3407:23): [True: 256, False: 0]
  ------------------
 3408|    256|        const size_t offset = seq.offset(i);
 3409|    256|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array + offset)))
  ------------------
  |  |  191|    256|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 256, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 256]
  |  |  |  Branch (191:57): [True: 256, False: 0]
  |  |  ------------------
  ------------------
 3410|    256|          return iterator_at_ptr(ctrl + offset, slot_array + offset);
 3411|    256|      }
 3412|      0|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3413|      0|      seq.next();
 3414|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= cap && "full table!");
  ------------------
  |  |  257|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3415|      0|    }
 3416|    256|  }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE7hash_ofIS8_EEmRKT_:
 3507|    256|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3508|    256|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3509|    256|                                               common().seed().seed()}(key);
 3510|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE15iterator_at_ptrEPNS1_6ctrl_tEPv:
 3816|    256|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3817|    256|    return {ctrl, to_slot(slot), common().generation_ptr()};
 3818|    256|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE14const_iteratorC2ENSA_8iteratorE:
 2494|    512|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE3endEv:
 2770|    256|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2771|    256|    return const_cast<raw_hash_set*>(this)->end();
 2772|    256|  }
_ZN4absl12lts_2026081718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE14const_iteratorESD_:
 2508|    256|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2509|    256|      return !(a == b);
 2510|    256|    }
_ZN4absl12lts_2026081718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE14const_iteratorESD_:
 2505|    256|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2506|    256|      return a.inner_ == b.inner_;
 2507|    256|    }
_ZN4absl12lts_2026081718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8iteratorESD_:
 2418|    256|    friend bool operator==(const iterator& a, const iterator& b) {
 2419|    256|      AssertIsValidForComparison(a.ctrl_, a.slot_, a.generation(),
 2420|    256|                                 a.generation_ptr());
 2421|    256|      AssertIsValidForComparison(b.ctrl_, b.slot_, b.generation(),
 2422|    256|                                 b.generation_ptr());
 2423|    256|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 2424|    256|                          a.generation_ptr(), b.generation_ptr());
 2425|    256|      return a.unchecked_equals(b);
 2426|    256|    }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8iterator16unchecked_equalsERKSB_:
 2462|    256|    bool unchecked_equals(const iterator& b) const { return slot_ == b.slot(); }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8iterator4slotEv:
 2469|    256|    slot_type* slot() const { return slot_; }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE14const_iteratorptEv:
 2497|    256|    pointer operator->() const { return inner_.operator->(); }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8iteratorptEv:
 2397|    256|    pointer operator->() const {
 2398|    256|      assert_is_full("operator->");
 2399|    256|      return &operator*();
 2400|    256|    }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8iterator14assert_is_fullEPKc:
 2445|    512|    void assert_is_full(const char* operation) const {
 2446|    512|      AssertIsFull(ctrl_, slot_, generation(), generation_ptr(), operation);
 2447|    512|    }
_ZNK4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEhEEJEE8iteratordeEv:
 2391|    256|    reference operator*() const {
 2392|    256|      assert_is_full("operator*()");
 2393|    256|      return unchecked_deref();
 2394|    256|    }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5beginEv:
 2753|      1|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2754|      1|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2755|      1|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2755:9): [True: 0, False: 1]
  ------------------
 2756|      1|    iterator it = {control(), slot_array(capacity()),
 2757|      1|                   common().generation_ptr()};
 2758|      1|    it.skip_empty_or_deleted();
 2759|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  257|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2760|      1|    return it;
 2761|      1|  }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator21skip_empty_or_deletedEv:
 2451|     40|    void skip_empty_or_deleted() {
 2452|     59|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2452:14): [True: 19, False: 40]
  ------------------
 2453|     19|        ++ctrl_;
 2454|     19|        ++slot_;
 2455|     19|      }
 2456|     40|    }
_ZN4absl12lts_2026081718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorESD_:
 2427|     40|    friend bool operator!=(const iterator& a, const iterator& b) {
 2428|     40|      return !(a == b);
 2429|     40|    }
_ZN4absl12lts_2026081718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorppEv:
 2403|     39|    iterator& operator++() {
 2404|     39|      assert_is_full("operator++");
 2405|     39|      ++ctrl_;
 2406|     39|      ++slot_;
 2407|     39|      skip_empty_or_deleted();
 2408|     39|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) slot_ = nullptr;
  ------------------
  |  |  190|     39|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 38]
  |  |  |  Branch (190:49): [Folded, False: 39]
  |  |  |  Branch (190:58): [True: 1, False: 38]
  |  |  ------------------
  ------------------
 2409|     39|      return *this;
 2410|     39|    }

_ZNK4absl12lts_2026081711FunctionRefIFvPN6google8protobuf5ArenaERPvEEclES5_S7_:
  164|    298|  R operator()(Args... args) const {
  165|    298|    return invoker_(ptr_, std::forward<Args>(args)...);
  166|    298|  }
_ZN4absl12lts_2026081711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEELb1EEEvEEOT_:
  112|      2|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026081711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEELb1EEEEENS8_10in_place_tEOT_:
  100|      2|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|      2|    absl::functional_internal::AssertNonNull(f);
  102|      2|    ptr_.obj = &f;
  103|      2|  }

_ZN4absl12lts_2026081719functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS3_10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEELb1EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   72|      1|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   73|      1|  using T = std::remove_reference_t<Obj>;
   74|      1|  return static_cast<R>(std::invoke(
   75|      1|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   76|      1|      std::forward<typename ForwardT<Args>::type>(args)...));
   77|      1|}
_ZN4absl12lts_2026081719functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS3_10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEELb1EEEEEvRKT_:
  134|      2|void AssertNonNull(const F&) {}

_ZN4absl12lts_2026081713hash_internal15MixingHashState18combine_contiguousES2_PKhm:
 1449|  1.25k|                                            size_t size) {
 1450|  1.25k|    return MixingHashState(
 1451|  1.25k|        CombineContiguousImpl(hash_state.state_, first, size,
 1452|  1.25k|                              std::integral_constant<int, sizeof(size_t)>{}));
 1453|  1.25k|  }
_ZN4absl12lts_2026081713hash_internal15MixingHashStateC2Em:
 1500|  2.51k|  explicit MixingHashState(uint64_t state) : state_(state) {}
_ZN4absl12lts_2026081713hash_internal19PrecombineLengthMixEmm:
 1056|  1.25k|inline uint64_t PrecombineLengthMix(uint64_t state, size_t len) {
 1057|  1.25k|  ABSL_ASSUME(len + sizeof(uint64_t) <= sizeof(kStaticRandomData));
  ------------------
  |  |  272|  1.25k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1058|  1.25k|  uint64_t data = absl::base_internal::UnalignedLoad64(
 1059|  1.25k|      reinterpret_cast<const unsigned char*>(&kStaticRandomData[0]) + len);
 1060|  1.25k|  return state ^ data;
 1061|  1.25k|}
_ZN4absl12lts_2026081713hash_internal3MixEmm:
 1063|  1.25k|ABSL_ATTRIBUTE_ALWAYS_INLINE inline uint64_t Mix(uint64_t lhs, uint64_t rhs) {
 1064|       |  // Though the 128-bit product needs multiple instructions on non-x86-64
 1065|       |  // platforms, it is still a good balance between speed and hash quality.
 1066|  1.25k|  absl::uint128 m = lhs;
 1067|  1.25k|  m *= rhs;
 1068|  1.25k|  return Uint128High64(m) ^ Uint128Low64(m);
 1069|  1.25k|}
_ZN4absl12lts_2026081713hash_internal8Read4To8EPKhm:
 1096|  1.22k|inline uint64_t Read4To8(const unsigned char* p, size_t len) {
 1097|       |  // If `len < 8`, we duplicate bytes. We always put low memory at the end.
 1098|       |  // E.g., on little endian platforms:
 1099|       |  // `ABCD` will be read as `ABCDABCD`.
 1100|       |  // `ABCDE` will be read as `BCDEABCD`.
 1101|       |  // `ABCDEF` will be read as `CDEFABCD`.
 1102|       |  // `ABCDEFG` will be read as `DEFGABCD`.
 1103|       |  // `ABCDEFGH` will be read as `EFGHABCD`.
 1104|       |  // We also do not care about endianness. On big-endian platforms, bytes will
 1105|       |  // be permuted differently. We always shift low memory by 32, because that
 1106|       |  // can be pipelined earlier. Reading high memory requires computing
 1107|       |  // `p + len - 4`.
 1108|  1.22k|  uint64_t most_significant =
 1109|  1.22k|      static_cast<uint64_t>(absl::base_internal::UnalignedLoad32(p)) << 32;
 1110|  1.22k|  uint64_t least_significant =
 1111|  1.22k|      absl::base_internal::UnalignedLoad32(p + len - 4);
 1112|  1.22k|  return most_significant | least_significant;
 1113|  1.22k|}
_ZN4absl12lts_2026081713hash_internal8Read1To3EPKhm:
 1116|     33|inline uint32_t Read1To3(const unsigned char* p, size_t len) {
 1117|       |  // The trick used by this implementation is to avoid branches.
 1118|       |  // We always read three bytes by duplicating.
 1119|       |  // E.g.,
 1120|       |  // `A` is read as `AAA`.
 1121|       |  // `AB` is read as `ABB`.
 1122|       |  // `ABC` is read as `ABC`.
 1123|       |  // We always shift `p[0]` so that it can be pipelined better.
 1124|       |  // Other bytes require extra computation to find indices.
 1125|     33|  uint32_t mem0 = (static_cast<uint32_t>(p[0]) << 16) | p[len - 1];
 1126|     33|  uint32_t mem1 = static_cast<uint32_t>(p[len / 2]) << 8;
 1127|     33|  return mem0 | mem1;
 1128|     33|}
_ZN4absl12lts_2026081713hash_internal14CombineRawImplEmm:
 1171|  1.25k|                                                            uint64_t value) {
 1172|  1.25k|  return Mix(state ^ value, kMul);
 1173|  1.25k|}
_ZN4absl12lts_2026081713hash_internal26CombineSmallContiguousImplEmPKhm:
 1187|  1.25k|    uint64_t state, const unsigned char* first, size_t len) {
 1188|  1.25k|  ABSL_ASSUME(len <= 8);
  ------------------
  |  |  272|  1.25k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1189|  1.25k|  uint64_t v;
 1190|  1.25k|  if (len >= 4) {
  ------------------
  |  Branch (1190:7): [True: 1.22k, False: 33]
  ------------------
 1191|  1.22k|    v = Read4To8(first, len);
 1192|  1.22k|  } else if (len > 0) {
  ------------------
  |  Branch (1192:14): [True: 33, False: 0]
  ------------------
 1193|     33|    v = Read1To3(first, len);
 1194|     33|  } else {
 1195|       |    // Empty string must modify the state.
 1196|      0|    v = 0x57;
 1197|      0|  }
 1198|  1.25k|  return CombineRawImpl(state, v);
 1199|  1.25k|}
_ZN4absl12lts_2026081713hash_internal21CombineContiguousImplEmPKhmNSt3__117integral_constantIiLi8EEE:
 1311|  1.25k|    std::integral_constant<int, 8> /* sizeof_size_t */) {
 1312|       |  // For large values we use LowLevelHash or CityHash depending on the platform,
 1313|       |  // for small ones we use custom low latency hash.
 1314|  1.25k|  if (len <= 8) {
  ------------------
  |  Branch (1314:7): [True: 1.25k, False: 0]
  ------------------
 1315|  1.25k|    return CombineSmallContiguousImpl(PrecombineLengthMix(state, len), first,
 1316|  1.25k|                                      len);
 1317|  1.25k|  }
 1318|      0|  if (len <= 16) {
  ------------------
  |  Branch (1318:7): [True: 0, False: 0]
  ------------------
 1319|      0|    return CombineContiguousImpl9to16(PrecombineLengthMix(state, len), first,
 1320|      0|                                      len);
 1321|      0|  }
 1322|      0|  if (len <= 32) {
  ------------------
  |  Branch (1322:7): [True: 0, False: 0]
  ------------------
 1323|      0|    return CombineContiguousImpl17to32(PrecombineLengthMix(state, len), first,
 1324|      0|                                       len);
 1325|      0|  }
 1326|       |  // We must not mix length into the state here because calling
 1327|       |  // CombineContiguousImpl twice with PiecewiseChunkSize() must be equivalent
 1328|       |  // to calling CombineLargeContiguousImpl once with 2 * PiecewiseChunkSize().
 1329|      0|  return CombineLargeContiguousImplOn64BitLengthGt32(state, first, len);
 1330|      0|}
_ZN4absl12lts_2026081713hash_internal15MixingHashState14hash_with_seedINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETnNS4_9enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSA_m:
 1473|  1.25k|  static size_t hash_with_seed(const T& value, size_t seed) {
 1474|  1.25k|    return static_cast<size_t>(combine(MixingHashState{seed}, value).state_);
 1475|  1.25k|  }
_ZN4absl12lts_2026081713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEES3_S3_RKT_DpRKT0_:
 1598|  1.25k|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1599|  1.25k|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1600|  1.25k|                        std::move(state), value),
 1601|  1.25k|                    values...);
 1602|  1.25k|}
_ZN4absl12lts_2026081713hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEENS6_9enable_ifIXsr3stdE9is_same_vIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEESC_E4typeESC_RKT0_:
 1376|  1.25k|        H> {
 1377|  1.25k|      return AbslHashValue(std::move(state), value);
 1378|  1.25k|    }
_ZN4absl12lts_2026081713hash_internal13AbslHashValueINS1_15MixingHashStateEEET_S4_NSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  659|  1.25k|H AbslHashValue(H hash_state, absl::string_view str) {
  660|  1.25k|  return H::combine_contiguous(std::move(hash_state), str.data(), str.size());
  661|  1.25k|}
_ZN4absl12lts_2026081713hash_internal13HashStateBaseINS1_15MixingHashStateEE18combine_contiguousIcEES3_S3_PKT_m:
 1606|  1.25k|H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
 1607|  1.25k|  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
 1608|  1.25k|}
_ZN4absl12lts_2026081713hash_internal19hash_range_or_bytesINS1_15MixingHashStateEcEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES7_PKS6_m:
 1029|  1.25k|    H hash_state, const T* data, size_t size) {
 1030|  1.25k|  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
 1031|  1.25k|  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
 1032|  1.25k|}
_ZN4absl12lts_2026081713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineES3_:
  299|  1.25k|  static H combine(H state) { return state; }
_ZNK4absl12lts_2026081713hash_internal12HashWithSeed4hashINS1_4HashINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEES9_EEmRKT_RKT0_m:
  412|  1.25k|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  413|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  414|  1.25k|    return hasher.hash_with_seed(value, seed);
  415|  1.25k|  }
_ZNK4absl12lts_2026081713hash_internal8HashImplINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE14hash_with_seedERKS7_m:
 1587|  1.25k|  size_t hash_with_seed(const T& value, size_t seed) const {
 1588|  1.25k|    return MixingHashState::hash_with_seed(value, seed);
 1589|  1.25k|  }
_ZNK4absl12lts_2026081713hash_internal12HashWithSeed4hashINS0_18container_internal10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEmRKT_RKT0_m:
  412|    703|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  413|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  414|    703|    return hasher.hash_with_seed(value, seed);
  415|    703|  }
_ZNK4absl12lts_2026081713hash_internal12HashWithSeed4hashINS0_18container_internal10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEmRKT_RKT0_m:
  412|    553|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  413|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  414|    553|    return hasher.hash_with_seed(value, seed);
  415|    553|  }

_ZN4absl12lts_202608177uint128mLES1_:
  646|  1.25k|inline uint128& uint128::operator*=(uint128 other) {
  647|  1.25k|  *this = *this * other;
  648|  1.25k|  return *this;
  649|  1.25k|}
_ZN4absl12lts_2026081712Uint128Low64ENS0_7uint128E:
  661|  1.25k|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl12lts_2026081713Uint128High64ENS0_7uint128E:
  663|  1.25k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZNK4absl12lts_202608177uint128cvoEv:
  794|  2.51k|constexpr uint128::operator unsigned __int128() const {
  795|  2.51k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  796|  2.51k|}
_ZN4absl12lts_20260817mlENS0_7uint128ES1_:
 1059|  1.25k|constexpr uint128 operator*(uint128 lhs, uint128 rhs) {
 1060|       |  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
 1061|       |  // can be used for uint128 storage.
 1062|  1.25k|  return static_cast<unsigned __int128>(lhs) *
 1063|  1.25k|         static_cast<unsigned __int128>(rhs);
 1064|  1.25k|}
_ZN4absl12lts_202608177uint128C2Em:
  683|  2.51k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
_ZN4absl12lts_202608177uint128C2Eo:
  692|  1.25k|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  693|  1.25k|      hi_{static_cast<uint64_t>(v >> 64)} {}

_ZN4absl12lts_202608176StatusC2Em:
  770|     50|  explicit Status(uintptr_t rep) : rep_(rep) {}
_ZN4absl12lts_202608176Status12MovedFromRepEv:
 1102|     19|constexpr uintptr_t Status::MovedFromRep() {
 1103|     19|  return CodeToInlinedRep(absl::StatusCode::kInternal) | 2;
 1104|     19|}
_ZN4absl12lts_202608176Status3RefEm:
 1117|     19|inline void Status::Ref(uintptr_t rep) {
 1118|     19|  if (!IsInlined(rep)) RepToPointer(rep)->Ref();
  ------------------
  |  Branch (1118:7): [True: 0, False: 19]
  ------------------
 1119|     19|}
_ZN4absl12lts_202608178OkStatusEv:
 1126|     11|inline Status OkStatus() { return Status(); }
_ZN4absl12lts_202608176StatusC2EOS1_:
  979|     19|inline Status::Status(Status&& x) noexcept : Status(x.rep_) {
  980|     19|  x.rep_ = MovedFromRep();
  981|     19|}
_ZN4absl12lts_202608176StatusC2Ev:
  950|     12|inline Status::Status() : Status(absl::StatusCode::kOk) {}
_ZN4absl12lts_202608176StatusC2ENS0_10StatusCodeE:
  952|     12|inline Status::Status(absl::StatusCode code) : Status(CodeToInlinedRep(code)) {}
_ZN4absl12lts_202608176StatusC2ERKS1_:
  966|     19|inline Status::Status(const Status& x) : Status(x.rep_) { Ref(rep_); }

_ZN4absl12lts_2026081721status_macro_internal12MacroAdaptorEONS0_6StatusENSt3__115source_locationE:
  444|     19|                                         absl::SourceLocation loc) {
  445|     19|  return ReturnIfErrorAdaptor(std::move(s), loc);
  446|     19|}
_ZN4absl12lts_2026081721status_macro_internal20ReturnIfErrorAdaptorC2EONS0_6StatusENSt3__115source_locationE:
  404|     19|      : status_(std::move(status)), loc_(loc) {}
_ZNK4absl12lts_2026081721status_macro_internal20ReturnIfErrorAdaptorcvbEv:
  420|     19|  explicit operator bool() const { return ABSL_PREDICT_TRUE(status_.ok()); }
  ------------------
  |  |  191|     19|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:48): [Folded, False: 19]
  |  |  |  Branch (191:57): [True: 19, False: 0]
  |  |  ------------------
  ------------------
_ZN4absl12lts_2026081721status_macro_internal20ReturnIfErrorAdaptorD2Ev:
  406|     19|  ~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|     19|  }

_ZN4absl12lts_2026081719str_format_internal14ExtractCharSetILNS0_23FormatConversionCharSetE655355EEES3_NS1_16ArgConvertResultIXT_EEE:
  205|    256|constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
  206|    256|  return C;
  207|    256|}
_ZN4absl12lts_2026081719str_format_internal13FormatArgImplC2IiEERKT_:
  490|    256|  explicit FormatArgImpl(const T& value) {
  491|    256|    using D = typename DecayType<T>::type;
  492|    256|    static_assert(
  493|    256|        std::is_same_v<D, const T&> || storage_policy<D>::value == ByValue,
  494|    256|        "Decayed types must be stored by value");
  495|    256|    Init(static_cast<D>(value));
  496|    256|  }
_ZN4absl12lts_2026081719str_format_internal13FormatArgImpl4InitIiEEvRKT_:
  543|    256|  void Init(const T& value) {
  544|    256|    data_ = Manager<T>::SetValue(value);
  545|    256|    dispatcher_ = &Dispatch<T>;
  546|    256|  }
_ZN4absl12lts_2026081719str_format_internal13FormatArgImpl7ManagerIiLNS2_13StoragePolicyE2EE8SetValueERKi:
  529|    256|    static Data SetValue(const T& value) {
  530|    256|      Data data;
  531|    256|      memcpy(data.buf, &value, sizeof(value));
  532|    256|      return data;
  533|    256|    }
_ZN4absl12lts_2026081719str_format_internal13FormatArgImpl8DispatchIiEEbNS2_4DataENS1_24FormatConversionSpecImplEPv:
  584|    256|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  585|       |    // A `none` conv indicates that we want the `int` conversion.
  586|    256|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  Branch (190:58): [True: 0, False: 256]
  |  |  ------------------
  ------------------
  587|    256|                           FormatConversionCharInternal::kNone)) {
  588|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  589|      0|                      std::is_enum<T>());
  590|      0|    }
  591|    256|    if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|    256|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 256]
  |  |  |  Branch (190:49): [Folded, False: 256]
  |  |  |  Branch (190:58): [True: 0, False: 256]
  |  |  ------------------
  ------------------
  592|    256|            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
  593|      0|      return false;
  594|      0|    }
  595|    256|    return str_format_internal::FormatConvertImpl(
  596|    256|               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
  597|    256|        .value;
  598|    256|  }
_ZN4absl12lts_2026081719str_format_internal14ArgumentToConvIiEENS0_23FormatConversionCharSetEv:
  418|    256|constexpr FormatConversionCharSet ArgumentToConv() {
  419|    256|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  420|    256|      std::declval<const Arg&>(),
  421|    256|      std::declval<const FormatConversionSpecImpl&>(),
  422|    256|      std::declval<FormatSinkImpl*>()));
  423|    256|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  424|    256|}
_ZN4absl12lts_2026081719str_format_internal13FormatArgImpl7ManagerIiLNS2_13StoragePolicyE2EE5ValueENS2_4DataE:
  535|    256|    static T Value(Data arg) {
  536|    256|      T value;
  537|    256|      memcpy(&value, arg.buf, sizeof(T));
  538|    256|      return value;
  539|    256|    }

_ZN4absl12lts_2026081719str_format_internal21UntypedFormatSpecImplC2ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   56|    256|      : data_(s.data()), size_(s.size()) {}
_ZN4absl12lts_2026081719str_format_internal21UntypedFormatSpecImpl7ExtractINS1_18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE655355EEEEEERKS2_RKT_:
   73|    256|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|    256|    return s.spec_;
   75|    256|  }
_ZN4absl12lts_2026081719str_format_internal18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE655355EEEC2EUa9enable_ifIXclL_ZNS1_15ValidFormatImplIJLS3_655355EEEEbNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEfL0p_EEEPKc:
  159|    256|      : Base(s) {}

_ZNK4absl12lts_2026081719str_format_internal24FormatConversionSpecImpl15conversion_charEv:
  290|  2.04k|  FormatConversionChar conversion_char() const {
  291|       |    // Keep this field first in the struct . It generates better code when
  292|       |    // accessing it when ConversionSpec is passed by value in registers.
  293|  2.04k|    static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
  294|  2.04k|    return conv_;
  295|  2.04k|  }
_ZN4absl12lts_2026081719str_format_internal29FormatConversionCharToConvIntENS0_20FormatConversionCharE:
  360|    256|constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
  361|    256|  return uint64_t{1} << (1 + static_cast<uint8_t>(c));
  362|    256|}
_ZN4absl12lts_2026081719str_format_internal8ContainsENS0_23FormatConversionCharSetENS0_20FormatConversionCharE:
  442|    256|constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) {
  443|    256|  return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
  444|    256|}

_ZN4absl12lts_2026081717UntypedFormatSpecC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  112|    256|  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
_ZN4absl12lts_202608179StrFormatIJiEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSB_:
  366|    256|                                    const Args&... args) {
  367|    256|  return str_format_internal::FormatPack(
  368|    256|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  369|    256|      {str_format_internal::FormatArgImpl(args)...});
  370|    256|}

_ZN4absl12lts_202608175MutexD2Ev:
 1195|      1|inline Mutex::~Mutex() { Dtor(); }
_ZN4absl12lts_202608175Mutex4DtorEv:
 1206|      1|inline void Mutex::Dtor() {}

_ZN4absl12lts_202608174SpanIKNS0_19str_format_internal13FormatArgImplEEC2IS4_S4_EESt16initializer_listIS3_E:
  308|    256|      : Span(v.begin(), v.size()) {}
_ZN4absl12lts_202608174SpanIKNS0_19str_format_internal13FormatArgImplEEC2EPS4_m:
  228|    256|      : ptr_(array), len_(length) {}

_ZN5Darts7Details15DoubleArrayUnitC2Ev:
   53|    256|  DoubleArrayUnit() : unit_() {}
_ZNK5Darts7Details15DoubleArrayUnit8has_leafEv:
   57|     93|  bool has_leaf() const {
   58|     93|    return ((unit_ >> 8) & 1) == 1;
   59|     93|  }
_ZNK5Darts7Details15DoubleArrayUnit5valueEv:
   62|     58|  value_type value() const {
   63|     58|    return static_cast<value_type>(unit_ & ((1U << 31) - 1));
   64|     58|  }
_ZNK5Darts7Details15DoubleArrayUnit5labelEv:
   69|     94|  id_type label() const {
   70|     94|    return unit_ & ((1U << 31) | 0xFF);
   71|     94|  }
_ZNK5Darts7Details15DoubleArrayUnit6offsetEv:
   73|    133|  id_type offset() const {
   74|    133|    return (unit_ >> 10) << ((unit_ & (1U << 9)) >> 6);
   75|    133|  }
_ZN5Darts7Details9BitVectorC2Ev:
  804|      1|  BitVector() : units_(), ranks_(), num_ones_(0), size_(0) {}
_ZN5Darts7Details9BitVectorD2Ev:
  805|      1|  ~BitVector() {
  806|      1|    clear();
  807|      1|  }
_ZNK5Darts7Details9BitVectorixEm:
  809|    120|  bool operator[](std::size_t id) const {
  810|    120|    return (units_[id / UNIT_SIZE] >> (id % UNIT_SIZE) & 1) == 1;
  811|    120|  }
_ZNK5Darts7Details9BitVector8num_onesEv:
  830|      2|  std::size_t num_ones() const {
  831|      2|    return num_ones_;
  832|      2|  }
_ZNK5Darts7Details9BitVector4sizeEv:
  833|     99|  std::size_t size() const {
  834|     99|    return size_;
  835|     99|  }
_ZN5Darts7Details9BitVector6appendEv:
  837|     99|  void append() {
  838|     99|    if ((size_ % UNIT_SIZE) == 0) {
  ------------------
  |  Branch (838:9): [True: 4, False: 95]
  ------------------
  839|      4|      units_.append(0);
  840|      4|    }
  841|     99|    ++size_;
  842|     99|  }
_ZN5Darts7Details9BitVector5clearEv:
  845|      3|  void clear() {
  846|      3|    units_.clear();
  847|      3|    ranks_.clear();
  848|      3|  }
_ZN5Darts7Details9BitVector9pop_countEj:
  862|      4|  static id_type pop_count(id_type unit) {
  863|      4|    unit = ((unit & 0xAAAAAAAA) >> 1) + (unit & 0x55555555);
  864|      4|    unit = ((unit & 0xCCCCCCCC) >> 2) + (unit & 0x33333333);
  865|      4|    unit = ((unit >> 4) + unit) & 0x0F0F0F0F;
  866|      4|    unit += unit >> 8;
  867|      4|    unit += unit >> 16;
  868|      4|    return unit & 0xFF;
  869|      4|  }
_ZN5Darts7Details8DawgNodeC2Ev:
  950|     99|  DawgNode() : child_(0), sibling_(0), label_('\0'),
  951|     99|    is_state_(false), has_sibling_(false) {}
_ZN5Darts7Details8DawgNode9set_childEj:
  953|    158|  void set_child(id_type child) {
  954|    158|    child_ = child;
  955|    158|  }
_ZN5Darts7Details8DawgNode11set_siblingEj:
  956|     98|  void set_sibling(id_type sibling) {
  957|     98|    sibling_ = sibling;
  958|     98|  }
_ZN5Darts7Details8DawgNode9set_valueEi:
  959|     39|  void set_value(value_type value) {
  960|     39|    child_ = value;
  961|     39|  }
_ZN5Darts7Details8DawgNode9set_labelEh:
  962|     99|  void set_label(uchar_type label) {
  963|     99|    label_ = label;
  964|     99|  }
_ZN5Darts7Details8DawgNode12set_is_stateEb:
  965|     60|  void set_is_state(bool is_state) {
  966|     60|    is_state_ = is_state;
  967|     60|  }
_ZN5Darts7Details8DawgNode15set_has_siblingEb:
  968|     38|  void set_has_sibling(bool has_sibling) {
  969|     38|    has_sibling_ = has_sibling;
  970|     38|  }
_ZNK5Darts7Details8DawgNode5childEv:
  972|    269|  id_type child() const {
  973|    269|    return child_;
  974|    269|  }
_ZNK5Darts7Details8DawgNode7siblingEv:
  975|    394|  id_type sibling() const {
  976|    394|    return sibling_;
  977|    394|  }
_ZNK5Darts7Details8DawgNode5labelEv:
  981|    269|  uchar_type label() const {
  982|    269|    return label_;
  983|    269|  }
_ZNK5Darts7Details8DawgNode4unitEv:
  991|    199|  id_type unit() const {
  992|    199|    if (label_ == '\0') {
  ------------------
  |  Branch (992:9): [True: 78, False: 121]
  ------------------
  993|     78|      return (child_ << 1) | (has_sibling_ ? 1 : 0);
  ------------------
  |  Branch (993:31): [True: 18, False: 60]
  ------------------
  994|     78|    }
  995|    121|    return (child_ << 2) | (is_state_ ? 2 : 0) | (has_sibling_ ? 1 : 0);
  ------------------
  |  Branch (995:29): [True: 44, False: 77]
  |  Branch (995:51): [True: 58, False: 63]
  ------------------
  996|    199|  }
_ZN5Darts7Details8DawgUnitC2Ej:
 1014|     99|  explicit DawgUnit(id_type unit = 0) : unit_(unit) {}
_ZN5Darts7Details8DawgUnitC2ERKS1_:
 1015|    127|  DawgUnit(const DawgUnit &unit) : unit_(unit.unit_) {}
_ZN5Darts7Details8DawgUnitaSEj:
 1017|     99|  DawgUnit &operator=(id_type unit) {
 1018|     99|    unit_ = unit;
 1019|     99|    return *this;
 1020|     99|  }
_ZNK5Darts7Details8DawgUnit4unitEv:
 1022|      2|  id_type unit() const {
 1023|      2|    return unit_;
 1024|      2|  }
_ZNK5Darts7Details8DawgUnit5childEv:
 1026|    181|  id_type child() const {
 1027|    181|    return unit_ >> 2;
 1028|    181|  }
_ZNK5Darts7Details8DawgUnit11has_siblingEv:
 1029|    296|  bool has_sibling() const {
 1030|    296|    return (unit_ & 1) == 1;
 1031|    296|  }
_ZNK5Darts7Details8DawgUnit5valueEv:
 1032|     39|  value_type value() const {
 1033|     39|    return static_cast<value_type>(unit_ >> 1);
 1034|     39|  }
_ZN5Darts7Details11DawgBuilderC2Ev:
 1051|      1|  DawgBuilder() : nodes_(), units_(), labels_(), is_intersections_(),
 1052|      1|    table_(), node_stack_(), recycle_bin_(), num_states_(0) {}
_ZN5Darts7Details11DawgBuilderD2Ev:
 1053|      1|  ~DawgBuilder() {
 1054|      1|    clear();
 1055|      1|  }
_ZNK5Darts7Details11DawgBuilder4rootEv:
 1057|      2|  id_type root() const {
 1058|      2|    return 0;
 1059|      2|  }
_ZNK5Darts7Details11DawgBuilder5childEj:
 1061|    181|  id_type child(id_type id) const {
 1062|    181|    return units_[id].child();
 1063|    181|  }
_ZNK5Darts7Details11DawgBuilder7siblingEj:
 1064|    294|  id_type sibling(id_type id) const {
 1065|    294|    return units_[id].has_sibling() ? (id + 1) : 0;
  ------------------
  |  Branch (1065:12): [True: 114, False: 180]
  ------------------
 1066|    294|  }
_ZNK5Darts7Details11DawgBuilder5valueEj:
 1067|     39|  int value(id_type id) const {
 1068|     39|    return units_[id].value();
 1069|     39|  }
_ZNK5Darts7Details11DawgBuilder7is_leafEj:
 1071|     98|  bool is_leaf(id_type id) const {
 1072|     98|    return label(id) == '\0';
 1073|     98|  }
_ZNK5Darts7Details11DawgBuilder5labelEj:
 1074|    294|  uchar_type label(id_type id) const {
 1075|    294|    return labels_[id];
 1076|    294|  }
_ZNK5Darts7Details11DawgBuilder15is_intersectionEj:
 1078|    120|  bool is_intersection(id_type id) const {
 1079|    120|    return is_intersections_[id];
 1080|    120|  }
_ZNK5Darts7Details11DawgBuilder17num_intersectionsEv:
 1085|      2|  std::size_t num_intersections() const {
 1086|      2|    return is_intersections_.num_ones();
 1087|      2|  }
_ZNK5Darts7Details11DawgBuilder4sizeEv:
 1089|      8|  std::size_t size() const {
 1090|      8|    return units_.size();
 1091|      8|  }
_ZN5Darts7Details11DawgBuilder9free_nodeEj:
 1131|     98|  void free_node(id_type id) {
 1132|     98|    recycle_bin_.push(id);
 1133|     98|  }
_ZN5Darts7Details11DawgBuilder4hashEj:
 1135|     98|  static id_type hash(id_type key) {
 1136|     98|    key = ~key + (key << 15);  // key = (key << 15) - key - 1;
 1137|     98|    key = key ^ (key >> 12);
 1138|     98|    key = key + (key << 2);
 1139|     98|    key = key ^ (key >> 4);
 1140|     98|    key = key * 2057;  // key = (key + (key << 3)) + (key << 11);
 1141|     98|    key = key ^ (key >> 16);
 1142|     98|    return key;
 1143|     98|  }
_ZN5Darts7Details22DoubleArrayBuilderUnitC2Ev:
 1397|    256|  DoubleArrayBuilderUnit() : unit_(0) {}
_ZN5Darts7Details22DoubleArrayBuilderUnit12set_has_leafEb:
 1399|     39|  void set_has_leaf(bool has_leaf) {
 1400|     39|    if (has_leaf) {
  ------------------
  |  Branch (1400:9): [True: 39, False: 0]
  ------------------
 1401|     39|      unit_ |= 1U << 8;
 1402|     39|    } else {
 1403|      0|      unit_ &= ~(1U << 8);
 1404|      0|    }
 1405|     39|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit9set_valueEi:
 1406|     39|  void set_value(value_type value) {
 1407|     39|    unit_ = value | (1U << 31);
 1408|     39|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit9set_labelEh:
 1409|    217|  void set_label(uchar_type label) {
 1410|    217|    unit_ = (unit_ & ~0xFFU) | label;
 1411|    217|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit10set_offsetEj:
 1412|     61|  void set_offset(id_type offset) {
 1413|     61|    if (offset >= 1U << 29) {
  ------------------
  |  Branch (1413:9): [True: 0, False: 61]
  ------------------
 1414|      0|      DARTS_THROW("failed to modify unit: too large offset");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1415|      0|    }
 1416|     61|    unit_ &= (1U << 31) | (1U << 8) | 0xFF;
 1417|     61|    if (offset < 1U << 21) {
  ------------------
  |  Branch (1417:9): [True: 61, False: 0]
  ------------------
 1418|     61|      unit_ |= (offset << 10);
 1419|     61|    } else {
 1420|      0|      unit_ |= (offset << 2) | (1U << 9);
 1421|      0|    }
 1422|     61|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnitC2Ev:
 1436|  4.09k|  DoubleArrayBuilderExtraUnit() : prev_(0), next_(0),
 1437|  4.09k|      is_fixed_(false), is_used_(false) {}
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit8set_prevEj:
 1439|    514|  void set_prev(id_type prev) {
 1440|    514|    prev_ = prev;
 1441|    514|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit8set_nextEj:
 1442|    514|  void set_next(id_type next) {
 1443|    514|    next_ = next;
 1444|    514|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit12set_is_fixedEb:
 1445|    256|  void set_is_fixed(bool is_fixed) {
 1446|    256|    is_fixed_ = is_fixed;
 1447|    256|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit11set_is_usedEb:
 1448|     61|  void set_is_used(bool is_used) {
 1449|     61|    is_used_ = is_used;
 1450|     61|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit4prevEv:
 1452|    514|  id_type prev() const {
 1453|    514|    return prev_;
 1454|    514|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit4nextEv:
 1455|    787|  id_type next() const {
 1456|    787|    return next_;
 1457|    787|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit8is_fixedEv:
 1458|    305|  bool is_fixed() const {
 1459|    305|    return is_fixed_;
 1460|    305|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit7is_usedEv:
 1461|    132|  bool is_used() const {
 1462|    132|    return is_used_;
 1463|    132|  }
_ZN5Darts7Details18DoubleArrayBuilderC2EPFimmE:
 1481|      1|      : progress_func_(progress_func), units_(), extras_(), labels_(),
 1482|      1|        table_(), extras_head_(0) {}
_ZN5Darts7Details18DoubleArrayBuilderD2Ev:
 1483|      1|  ~DoubleArrayBuilder() {
 1484|      1|    clear();
 1485|      1|  }
_ZNK5Darts7Details18DoubleArrayBuilder10num_blocksEv:
 1515|      3|  std::size_t num_blocks() const {
 1516|      3|    return units_.size() / BLOCK_SIZE;
 1517|      3|  }
_ZNK5Darts7Details18DoubleArrayBuilder6extrasEj:
 1519|    249|  const extra_type &extras(id_type id) const {
 1520|    249|    return extras_[id % NUM_EXTRAS];
 1521|    249|  }
_ZN5Darts7Details18DoubleArrayBuilder6extrasEj:
 1522|  2.83k|  extra_type &extras(id_type id) {
 1523|  2.83k|    return extras_[id % NUM_EXTRAS];
 1524|  2.83k|  }
_ZN5Darts7Details9BitVector5buildEv:
  872|      1|inline void BitVector::build() {
  873|      1|  try {
  874|      1|    ranks_.reset(new id_type[units_.size()]);
  875|      1|  } catch (const std::bad_alloc &) {
  876|      0|    DARTS_THROW("failed to build rank index: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  877|      0|  }
  878|       |
  879|      1|  num_ones_ = 0;
  880|      5|  for (std::size_t i = 0; i < units_.size(); ++i) {
  ------------------
  |  Branch (880:27): [True: 4, False: 1]
  ------------------
  881|      4|    ranks_[i] = num_ones_;
  882|      4|    num_ones_ += pop_count(units_[i]);
  883|      4|  }
  884|      1|}
_ZN5Darts7Details11DawgBuilder4initEv:
 1146|      1|inline void DawgBuilder::init() {
 1147|      1|  table_.resize(INITIAL_TABLE_SIZE, 0);
 1148|       |
 1149|      1|  append_node();
 1150|      1|  append_unit();
 1151|       |
 1152|      1|  num_states_ = 1;
 1153|       |
 1154|      1|  nodes_[0].set_label(0xFF);
 1155|      1|  node_stack_.push(0);
 1156|      1|}
_ZN5Darts7Details11DawgBuilder6finishEv:
 1158|      1|inline void DawgBuilder::finish() {
 1159|      1|  flush(0);
 1160|       |
 1161|      1|  units_[0] = nodes_[0].unit();
 1162|      1|  labels_[0] = nodes_[0].label();
 1163|       |
 1164|      1|  nodes_.clear();
 1165|      1|  table_.clear();
 1166|      1|  node_stack_.clear();
 1167|      1|  recycle_bin_.clear();
 1168|       |
 1169|      1|  is_intersections_.build();
 1170|      1|}
_ZN5Darts7Details11DawgBuilder6insertEPKcmi:
 1173|     39|    value_type value) {
 1174|     39|  if (value < 0) {
  ------------------
  |  Branch (1174:7): [True: 0, False: 39]
  ------------------
 1175|      0|    DARTS_THROW("failed to insert key: negative value");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1176|     39|  } else if (length == 0) {
  ------------------
  |  Branch (1176:14): [True: 0, False: 39]
  ------------------
 1177|      0|    DARTS_THROW("failed to insert key: zero-length key");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1178|      0|  }
 1179|       |
 1180|     39|  id_type id = 0;
 1181|     39|  std::size_t key_pos = 0;
 1182|       |
 1183|     73|  for ( ; key_pos <= length; ++key_pos) {
  ------------------
  |  Branch (1183:11): [True: 73, False: 0]
  ------------------
 1184|     73|    id_type child_id = nodes_[id].child();
 1185|     73|    if (child_id == 0) {
  ------------------
  |  Branch (1185:9): [True: 1, False: 72]
  ------------------
 1186|      1|      break;
 1187|      1|    }
 1188|       |
 1189|     72|    uchar_type key_label = static_cast<uchar_type>(key[key_pos]);
 1190|     72|    if (key_pos < length && key_label == '\0') {
  ------------------
  |  Branch (1190:9): [True: 72, False: 0]
  |  Branch (1190:29): [True: 0, False: 72]
  ------------------
 1191|      0|      DARTS_THROW("failed to insert key: invalid null character");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1192|      0|    }
 1193|       |
 1194|     72|    uchar_type unit_label = nodes_[child_id].label();
 1195|     72|    if (key_label < unit_label) {
  ------------------
  |  Branch (1195:9): [True: 0, False: 72]
  ------------------
 1196|      0|      DARTS_THROW("failed to insert key: wrong key order");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1197|     72|    } else if (key_label > unit_label) {
  ------------------
  |  Branch (1197:16): [True: 38, False: 34]
  ------------------
 1198|     38|      nodes_[child_id].set_has_sibling(true);
 1199|     38|      flush(child_id);
 1200|     38|      break;
 1201|     38|    }
 1202|     34|    id = child_id;
 1203|     34|  }
 1204|       |
 1205|     39|  if (key_pos > length) {
  ------------------
  |  Branch (1205:7): [True: 0, False: 39]
  ------------------
 1206|      0|    return;
 1207|      0|  }
 1208|       |
 1209|    137|  for ( ; key_pos <= length; ++key_pos) {
  ------------------
  |  Branch (1209:11): [True: 98, False: 39]
  ------------------
 1210|     98|    uchar_type key_label = static_cast<uchar_type>(
 1211|     98|        (key_pos < length) ? key[key_pos] : '\0');
  ------------------
  |  Branch (1211:9): [True: 59, False: 39]
  ------------------
 1212|     98|    id_type child_id = append_node();
 1213|       |
 1214|     98|    if (nodes_[id].child() == 0) {
  ------------------
  |  Branch (1214:9): [True: 60, False: 38]
  ------------------
 1215|     60|      nodes_[child_id].set_is_state(true);
 1216|     60|    }
 1217|     98|    nodes_[child_id].set_sibling(nodes_[id].child());
 1218|     98|    nodes_[child_id].set_label(key_label);
 1219|     98|    nodes_[id].set_child(child_id);
 1220|     98|    node_stack_.push(child_id);
 1221|       |
 1222|     98|    id = child_id;
 1223|     98|  }
 1224|     39|  nodes_[id].set_value(value);
 1225|     39|}
_ZN5Darts7Details11DawgBuilder5clearEv:
 1227|      2|inline void DawgBuilder::clear() {
 1228|      2|  nodes_.clear();
 1229|      2|  units_.clear();
 1230|      2|  labels_.clear();
 1231|      2|  is_intersections_.clear();
 1232|      2|  table_.clear();
 1233|      2|  node_stack_.clear();
 1234|      2|  recycle_bin_.clear();
 1235|      2|  num_states_ = 0;
 1236|      2|}
_ZN5Darts7Details11DawgBuilder5flushEj:
 1238|     39|inline void DawgBuilder::flush(id_type id) {
 1239|     99|  while (node_stack_.top() != id) {
  ------------------
  |  Branch (1239:10): [True: 60, False: 39]
  ------------------
 1240|     60|    id_type node_id = node_stack_.top();
 1241|     60|    node_stack_.pop();
 1242|       |
 1243|     60|    if (num_states_ >= table_.size() - (table_.size() >> 2)) {
  ------------------
  |  Branch (1243:9): [True: 0, False: 60]
  ------------------
 1244|      0|      expand_table();
 1245|      0|    }
 1246|       |
 1247|     60|    id_type num_siblings = 0;
 1248|    158|    for (id_type i = node_id; i != 0; i = nodes_[i].sibling()) {
  ------------------
  |  Branch (1248:31): [True: 98, False: 60]
  ------------------
 1249|     98|      ++num_siblings;
 1250|     98|    }
 1251|       |
 1252|     60|    id_type hash_id;
 1253|     60|    id_type match_id = find_node(node_id, &hash_id);
 1254|     60|    if (match_id != 0) {
  ------------------
  |  Branch (1254:9): [True: 0, False: 60]
  ------------------
 1255|      0|      is_intersections_.set(match_id, true);
 1256|     60|    } else {
 1257|     60|      id_type unit_id = 0;
 1258|    158|      for (id_type i = 0; i < num_siblings; ++i) {
  ------------------
  |  Branch (1258:27): [True: 98, False: 60]
  ------------------
 1259|     98|        unit_id = append_unit();
 1260|     98|      }
 1261|    158|      for (id_type i = node_id; i != 0; i = nodes_[i].sibling()) {
  ------------------
  |  Branch (1261:33): [True: 98, False: 60]
  ------------------
 1262|     98|        units_[unit_id] = nodes_[i].unit();
 1263|     98|        labels_[unit_id] = nodes_[i].label();
 1264|     98|        --unit_id;
 1265|     98|      }
 1266|     60|      match_id = unit_id + 1;
 1267|     60|      table_[hash_id] = match_id;
 1268|     60|      ++num_states_;
 1269|     60|    }
 1270|       |
 1271|    158|    for (id_type i = node_id, next; i != 0; i = next) {
  ------------------
  |  Branch (1271:37): [True: 98, False: 60]
  ------------------
 1272|     98|      next = nodes_[i].sibling();
 1273|     98|      free_node(i);
 1274|     98|    }
 1275|       |
 1276|     60|    nodes_[node_stack_.top()].set_child(match_id);
 1277|     60|  }
 1278|     39|  node_stack_.pop();
 1279|     39|}
_ZNK5Darts7Details11DawgBuilder9find_nodeEjPj:
 1310|     60|    id_type *hash_id) const {
 1311|     60|  *hash_id = hash_node(node_id) % table_.size();
 1312|     62|  for ( ; ; *hash_id = (*hash_id + 1) % table_.size()) {
 1313|     62|    id_type unit_id = table_[*hash_id];
 1314|     62|    if (unit_id == 0) {
  ------------------
  |  Branch (1314:9): [True: 60, False: 2]
  ------------------
 1315|     60|      break;
 1316|     60|    }
 1317|       |
 1318|      2|    if (are_equal(node_id, unit_id)) {
  ------------------
  |  Branch (1318:9): [True: 0, False: 2]
  ------------------
 1319|      0|      return unit_id;
 1320|      0|    }
 1321|      2|  }
 1322|     60|  return 0;
 1323|     60|}
_ZNK5Darts7Details11DawgBuilder9are_equalEjj:
 1325|      2|inline bool DawgBuilder::are_equal(id_type node_id, id_type unit_id) const {
 1326|      2|  for (id_type i = nodes_[node_id].sibling(); i != 0;
  ------------------
  |  Branch (1326:47): [True: 0, False: 2]
  ------------------
 1327|      2|      i = nodes_[i].sibling()) {
 1328|      0|    if (units_[unit_id].has_sibling() == false) {
  ------------------
  |  Branch (1328:9): [True: 0, False: 0]
  ------------------
 1329|      0|      return false;
 1330|      0|    }
 1331|      0|    ++unit_id;
 1332|      0|  }
 1333|      2|  if (units_[unit_id].has_sibling() == true) {
  ------------------
  |  Branch (1333:7): [True: 0, False: 2]
  ------------------
 1334|      0|    return false;
 1335|      0|  }
 1336|       |
 1337|      2|  for (id_type i = node_id; i != 0; i = nodes_[i].sibling(), --unit_id) {
  ------------------
  |  Branch (1337:29): [True: 2, False: 0]
  ------------------
 1338|      2|    if (nodes_[i].unit() != units_[unit_id].unit() ||
  ------------------
  |  Branch (1338:9): [True: 2, False: 0]
  ------------------
 1339|      2|        nodes_[i].label() != labels_[unit_id]) {
  ------------------
  |  Branch (1339:9): [True: 0, False: 0]
  ------------------
 1340|      2|      return false;
 1341|      2|    }
 1342|      2|  }
 1343|      0|  return true;
 1344|      2|}
_ZNK5Darts7Details11DawgBuilder9hash_nodeEj:
 1360|     60|inline id_type DawgBuilder::hash_node(id_type id) const {
 1361|     60|  id_type hash_value = 0;
 1362|    158|  for ( ; id != 0; id = nodes_[id].sibling()) {
  ------------------
  |  Branch (1362:11): [True: 98, False: 60]
  ------------------
 1363|     98|    id_type unit = nodes_[id].unit();
 1364|     98|    uchar_type label = nodes_[id].label();
 1365|     98|    hash_value ^= hash((label << 24) ^ unit);
 1366|     98|  }
 1367|     60|  return hash_value;
 1368|     60|}
_ZN5Darts7Details11DawgBuilder11append_unitEv:
 1370|     99|inline id_type DawgBuilder::append_unit() {
 1371|     99|  is_intersections_.append();
 1372|     99|  units_.append();
 1373|     99|  labels_.append();
 1374|       |
 1375|     99|  return static_cast<id_type>(is_intersections_.size() - 1);
 1376|     99|}
_ZN5Darts7Details11DawgBuilder11append_nodeEv:
 1378|     99|inline id_type DawgBuilder::append_node() {
 1379|     99|  id_type id;
 1380|     99|  if (recycle_bin_.empty()) {
  ------------------
  |  Branch (1380:7): [True: 36, False: 63]
  ------------------
 1381|     36|    id = static_cast<id_type>(nodes_.size());
 1382|     36|    nodes_.append();
 1383|     63|  } else {
 1384|     63|    id = recycle_bin_.top();
 1385|     63|    nodes_[id] = DawgNode();
 1386|     63|    recycle_bin_.pop();
 1387|     63|  }
 1388|     99|  return id;
 1389|     99|}
_ZNK5Darts7Details18DoubleArrayBuilder4copyEPmPPNS0_15DoubleArrayUnitE:
 1566|      1|    DoubleArrayUnit **buf_ptr) const {
 1567|      1|  if (size_ptr != NULL) {
  ------------------
  |  Branch (1567:7): [True: 1, False: 0]
  ------------------
 1568|      1|    *size_ptr = units_.size();
 1569|      1|  }
 1570|      1|  if (buf_ptr != NULL) {
  ------------------
  |  Branch (1570:7): [True: 1, False: 0]
  ------------------
 1571|      1|    *buf_ptr = new DoubleArrayUnit[units_.size()];
 1572|      1|    unit_type *units = reinterpret_cast<unit_type *>(*buf_ptr);
 1573|    257|    for (std::size_t i = 0; i < units_.size(); ++i) {
  ------------------
  |  Branch (1573:29): [True: 256, False: 1]
  ------------------
 1574|    256|      units[i] = units_[i];
 1575|    256|    }
 1576|      1|  }
 1577|      1|}
_ZN5Darts7Details18DoubleArrayBuilder5clearEv:
 1579|      1|inline void DoubleArrayBuilder::clear() {
 1580|      1|  units_.clear();
 1581|      1|  extras_.clear();
 1582|      1|  labels_.clear();
 1583|      1|  table_.clear();
 1584|      1|  extras_head_ = 0;
 1585|      1|}
_ZN5Darts7Details18DoubleArrayBuilder15build_from_dawgERKNS0_11DawgBuilderE:
 1600|      1|inline void DoubleArrayBuilder::build_from_dawg(const DawgBuilder &dawg) {
 1601|      1|  std::size_t num_units = 1;
 1602|      8|  while (num_units < dawg.size()) {
  ------------------
  |  Branch (1602:10): [True: 7, False: 1]
  ------------------
 1603|      7|    num_units <<= 1;
 1604|      7|  }
 1605|      1|  units_.reserve(num_units);
 1606|       |
 1607|      1|  table_.reset(new id_type[dawg.num_intersections()]);
 1608|      1|  for (std::size_t i = 0; i < dawg.num_intersections(); ++i) {
  ------------------
  |  Branch (1608:27): [True: 0, False: 1]
  ------------------
 1609|      0|    table_[i] = 0;
 1610|      0|  }
 1611|       |
 1612|      1|  extras_.reset(new extra_type[NUM_EXTRAS]);
 1613|       |
 1614|      1|  reserve_id(0);
 1615|      1|  extras(0).set_is_used(true);
 1616|      1|  units_[0].set_offset(1);
 1617|      1|  units_[0].set_label('\0');
 1618|       |
 1619|      1|  if (dawg.child(dawg.root()) != 0) {
  ------------------
  |  Branch (1619:7): [True: 1, False: 0]
  ------------------
 1620|      1|    build_from_dawg(dawg, dawg.root(), 0);
 1621|      1|  }
 1622|       |
 1623|      1|  fix_all_blocks();
 1624|       |
 1625|      1|  extras_.clear();
 1626|      1|  labels_.clear();
 1627|      1|  table_.clear();
 1628|      1|}
_ZN5Darts7Details18DoubleArrayBuilder15build_from_dawgERKNS0_11DawgBuilderEjj:
 1631|     60|    id_type dawg_id, id_type dic_id) {
 1632|     60|  id_type dawg_child_id = dawg.child(dawg_id);
 1633|     60|  if (dawg.is_intersection(dawg_child_id)) {
  ------------------
  |  Branch (1633:7): [True: 0, False: 60]
  ------------------
 1634|      0|    id_type intersection_id = dawg.intersection_id(dawg_child_id);
 1635|      0|    id_type offset = table_[intersection_id];
 1636|      0|    if (offset != 0) {
  ------------------
  |  Branch (1636:9): [True: 0, False: 0]
  ------------------
 1637|      0|      offset ^= dic_id;
 1638|      0|      if (!(offset & UPPER_MASK) || !(offset & LOWER_MASK)) {
  ------------------
  |  Branch (1638:11): [True: 0, False: 0]
  |  Branch (1638:37): [True: 0, False: 0]
  ------------------
 1639|      0|        if (dawg.is_leaf(dawg_child_id)) {
  ------------------
  |  Branch (1639:13): [True: 0, False: 0]
  ------------------
 1640|      0|          units_[dic_id].set_has_leaf(true);
 1641|      0|        }
 1642|      0|        units_[dic_id].set_offset(offset);
 1643|      0|        return;
 1644|      0|      }
 1645|      0|    }
 1646|      0|  }
 1647|       |
 1648|     60|  id_type offset = arrange_from_dawg(dawg, dawg_id, dic_id);
 1649|     60|  if (dawg.is_intersection(dawg_child_id)) {
  ------------------
  |  Branch (1649:7): [True: 0, False: 60]
  ------------------
 1650|      0|    table_[dawg.intersection_id(dawg_child_id)] = offset;
 1651|      0|  }
 1652|       |
 1653|     98|  do {
 1654|     98|    uchar_type child_label = dawg.label(dawg_child_id);
 1655|     98|    id_type dic_child_id = offset ^ child_label;
 1656|     98|    if (child_label != '\0') {
  ------------------
  |  Branch (1656:9): [True: 59, False: 39]
  ------------------
 1657|     59|      build_from_dawg(dawg, dawg_child_id, dic_child_id);
 1658|     59|    }
 1659|     98|    dawg_child_id = dawg.sibling(dawg_child_id);
 1660|     98|  } while (dawg_child_id != 0);
  ------------------
  |  Branch (1660:12): [True: 38, False: 60]
  ------------------
 1661|     60|}
_ZN5Darts7Details18DoubleArrayBuilder17arrange_from_dawgERKNS0_11DawgBuilderEjj:
 1664|     60|    id_type dawg_id, id_type dic_id) {
 1665|     60|  labels_.resize(0);
 1666|       |
 1667|     60|  id_type dawg_child_id = dawg.child(dawg_id);
 1668|    158|  while (dawg_child_id != 0) {
  ------------------
  |  Branch (1668:10): [True: 98, False: 60]
  ------------------
 1669|     98|    labels_.append(dawg.label(dawg_child_id));
 1670|     98|    dawg_child_id = dawg.sibling(dawg_child_id);
 1671|     98|  }
 1672|       |
 1673|     60|  id_type offset = find_valid_offset(dic_id);
 1674|     60|  units_[dic_id].set_offset(dic_id ^ offset);
 1675|       |
 1676|     60|  dawg_child_id = dawg.child(dawg_id);
 1677|    158|  for (std::size_t i = 0; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1677:27): [True: 98, False: 60]
  ------------------
 1678|     98|    id_type dic_child_id = offset ^ labels_[i];
 1679|     98|    reserve_id(dic_child_id);
 1680|       |
 1681|     98|    if (dawg.is_leaf(dawg_child_id)) {
  ------------------
  |  Branch (1681:9): [True: 39, False: 59]
  ------------------
 1682|     39|      units_[dic_id].set_has_leaf(true);
 1683|     39|      units_[dic_child_id].set_value(dawg.value(dawg_child_id));
 1684|     59|    } else {
 1685|     59|      units_[dic_child_id].set_label(labels_[i]);
 1686|     59|    }
 1687|       |
 1688|     98|    dawg_child_id = dawg.sibling(dawg_child_id);
 1689|     98|  }
 1690|     60|  extras(offset).set_is_used(true);
 1691|       |
 1692|     60|  return offset;
 1693|     60|}
_ZNK5Darts7Details18DoubleArrayBuilder17find_valid_offsetEj:
 1801|     60|inline id_type DoubleArrayBuilder::find_valid_offset(id_type id) const {
 1802|     60|  if (extras_head_ >= units_.size()) {
  ------------------
  |  Branch (1802:7): [True: 0, False: 60]
  ------------------
 1803|      0|    return units_.size() | (id & LOWER_MASK);
 1804|      0|  }
 1805|       |
 1806|     60|  id_type unfixed_id = extras_head_;
 1807|    130|  do {
 1808|    130|    id_type offset = unfixed_id ^ labels_[0];
 1809|    130|    if (is_valid_offset(id, offset)) {
  ------------------
  |  Branch (1809:9): [True: 60, False: 70]
  ------------------
 1810|     60|      return offset;
 1811|     60|    }
 1812|     70|    unfixed_id = extras(unfixed_id).next();
 1813|     70|  } while (unfixed_id != extras_head_);
  ------------------
  |  Branch (1813:12): [True: 70, False: 0]
  ------------------
 1814|       |
 1815|      0|  return units_.size() | (id & LOWER_MASK);
 1816|     60|}
_ZNK5Darts7Details18DoubleArrayBuilder15is_valid_offsetEjj:
 1819|    130|    id_type offset) const {
 1820|    130|  if (extras(offset).is_used()) {
  ------------------
  |  Branch (1820:7): [True: 64, False: 66]
  ------------------
 1821|     64|    return false;
 1822|     64|  }
 1823|       |
 1824|     66|  id_type rel_offset = id ^ offset;
 1825|     66|  if ((rel_offset & LOWER_MASK) && (rel_offset & UPPER_MASK)) {
  ------------------
  |  Branch (1825:7): [True: 66, False: 0]
  |  Branch (1825:36): [True: 0, False: 66]
  ------------------
 1826|      0|    return false;
 1827|      0|  }
 1828|       |
 1829|    109|  for (std::size_t i = 1; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1829:27): [True: 49, False: 60]
  ------------------
 1830|     49|    if (extras(offset ^ labels_[i]).is_fixed()) {
  ------------------
  |  Branch (1830:9): [True: 6, False: 43]
  ------------------
 1831|      6|      return false;
 1832|      6|    }
 1833|     49|  }
 1834|       |
 1835|     60|  return true;
 1836|     66|}
_ZN5Darts7Details18DoubleArrayBuilder10reserve_idEj:
 1838|    256|inline void DoubleArrayBuilder::reserve_id(id_type id) {
 1839|    256|  if (id >= units_.size()) {
  ------------------
  |  Branch (1839:7): [True: 1, False: 255]
  ------------------
 1840|      1|    expand_units();
 1841|      1|  }
 1842|       |
 1843|    256|  if (id == extras_head_) {
  ------------------
  |  Branch (1843:7): [True: 205, False: 51]
  ------------------
 1844|    205|    extras_head_ = extras(id).next();
 1845|    205|    if (extras_head_ == id) {
  ------------------
  |  Branch (1845:9): [True: 1, False: 204]
  ------------------
 1846|      1|      extras_head_ = units_.size();
 1847|      1|    }
 1848|    205|  }
 1849|    256|  extras(extras(id).prev()).set_next(extras(id).next());
 1850|    256|  extras(extras(id).next()).set_prev(extras(id).prev());
 1851|    256|  extras(id).set_is_fixed(true);
 1852|    256|}
_ZN5Darts7Details18DoubleArrayBuilder12expand_unitsEv:
 1854|      1|inline void DoubleArrayBuilder::expand_units() {
 1855|      1|  id_type src_num_units = units_.size();
 1856|      1|  id_type src_num_blocks = num_blocks();
 1857|       |
 1858|      1|  id_type dest_num_units = src_num_units + BLOCK_SIZE;
 1859|      1|  id_type dest_num_blocks = src_num_blocks + 1;
 1860|       |
 1861|      1|  if (dest_num_blocks > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1861:7): [True: 0, False: 1]
  ------------------
 1862|      0|    fix_block(src_num_blocks - NUM_EXTRA_BLOCKS);
 1863|      0|  }
 1864|       |
 1865|      1|  units_.resize(dest_num_units);
 1866|       |
 1867|      1|  if (dest_num_blocks > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1867:7): [True: 0, False: 1]
  ------------------
 1868|      0|    for (std::size_t id = src_num_units; id < dest_num_units; ++id) {
  ------------------
  |  Branch (1868:42): [True: 0, False: 0]
  ------------------
 1869|      0|      extras(id).set_is_used(false);
 1870|      0|      extras(id).set_is_fixed(false);
 1871|      0|    }
 1872|      0|  }
 1873|       |
 1874|    256|  for (id_type i = src_num_units + 1; i < dest_num_units; ++i) {
  ------------------
  |  Branch (1874:39): [True: 255, False: 1]
  ------------------
 1875|    255|    extras(i - 1).set_next(i);
 1876|    255|    extras(i).set_prev(i - 1);
 1877|    255|  }
 1878|       |
 1879|      1|  extras(src_num_units).set_prev(dest_num_units - 1);
 1880|      1|  extras(dest_num_units - 1).set_next(src_num_units);
 1881|       |
 1882|      1|  extras(src_num_units).set_prev(extras(extras_head_).prev());
 1883|      1|  extras(dest_num_units - 1).set_next(extras_head_);
 1884|       |
 1885|      1|  extras(extras(extras_head_).prev()).set_next(src_num_units);
 1886|      1|  extras(extras_head_).set_prev(dest_num_units - 1);
 1887|      1|}
_ZN5Darts7Details18DoubleArrayBuilder14fix_all_blocksEv:
 1889|      1|inline void DoubleArrayBuilder::fix_all_blocks() {
 1890|      1|  id_type begin = 0;
 1891|      1|  if (num_blocks() > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1891:7): [True: 0, False: 1]
  ------------------
 1892|      0|    begin = num_blocks() - NUM_EXTRA_BLOCKS;
 1893|      0|  }
 1894|      1|  id_type end = num_blocks();
 1895|       |
 1896|      2|  for (id_type block_id = begin; block_id != end; ++block_id) {
  ------------------
  |  Branch (1896:34): [True: 1, False: 1]
  ------------------
 1897|      1|    fix_block(block_id);
 1898|      1|  }
 1899|      1|}
_ZN5Darts7Details18DoubleArrayBuilder9fix_blockEj:
 1901|      1|inline void DoubleArrayBuilder::fix_block(id_type block_id) {
 1902|      1|  id_type begin = block_id * BLOCK_SIZE;
 1903|      1|  id_type end = begin + BLOCK_SIZE;
 1904|       |
 1905|      1|  id_type unused_offset = 0;
 1906|      2|  for (id_type offset = begin; offset != end; ++offset) {
  ------------------
  |  Branch (1906:32): [True: 2, False: 0]
  ------------------
 1907|      2|    if (!extras(offset).is_used()) {
  ------------------
  |  Branch (1907:9): [True: 1, False: 1]
  ------------------
 1908|      1|      unused_offset = offset;
 1909|      1|      break;
 1910|      1|    }
 1911|      2|  }
 1912|       |
 1913|    257|  for (id_type id = begin; id != end; ++id) {
  ------------------
  |  Branch (1913:28): [True: 256, False: 1]
  ------------------
 1914|    256|    if (!extras(id).is_fixed()) {
  ------------------
  |  Branch (1914:9): [True: 157, False: 99]
  ------------------
 1915|    157|      reserve_id(id);
 1916|    157|      units_[id].set_label(static_cast<uchar_type>(id ^ unused_offset));
 1917|    157|    }
 1918|    256|  }
 1919|      1|}
_ZN5Darts7Details9AutoArrayIcE5clearEv:
  608|    136|  void clear() {
  609|    136|    if (array_ != NULL) {
  ------------------
  |  Branch (609:9): [True: 47, False: 89]
  ------------------
  610|     47|      delete[] array_;
  611|       |      array_ = NULL;
  612|     47|    }
  613|    136|  }
_ZNK5Darts7Details8AutoPoolIjEixEm:
  641|    182|  const T &operator[](std::size_t id) const {
  642|    182|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  643|    182|  }
_ZNK5Darts7Details9AutoArrayIcEixEm:
  597|  1.72k|  const T &operator[](std::size_t id) const {
  598|  1.72k|    return array_[id];
  599|  1.72k|  }
_ZN5Darts7Details8AutoPoolIjEixEm:
  644|  2.79k|  T &operator[](std::size_t id) {
  645|  2.79k|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  646|  2.79k|  }
_ZN5Darts7Details9AutoArrayIcEixEm:
  600|  6.14k|  T &operator[](std::size_t id) {
  601|  6.14k|    return array_[id];
  602|  6.14k|  }
_ZNK5Darts7Details8AutoPoolIjE5emptyEv:
  648|     99|  bool empty() const {
  649|     99|    return size_ == 0;
  650|     99|  }
_ZN5Darts7Details8AutoPoolIjE6appendERKj:
  674|    201|  void append(const T &value) {
  675|    201|    if (size_ == capacity_)
  ------------------
  |  Branch (675:9): [True: 15, False: 186]
  ------------------
  676|     15|      resize_buf(size_ + 1);
  677|    201|    new(&(*this)[size_++]) T(value);
  678|    201|  }
_ZN5Darts7Details8AutoPoolIjE10resize_bufEm:
  722|     16|void AutoPool<T>::resize_buf(std::size_t size) {
  723|     16|  std::size_t capacity;
  724|     16|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (724:7): [True: 7, False: 9]
  ------------------
  725|      7|    capacity = size;
  726|      9|  } else {
  727|      9|    capacity = 1;
  728|     40|    while (capacity < size) {
  ------------------
  |  Branch (728:12): [True: 31, False: 9]
  ------------------
  729|     31|      capacity <<= 1;
  730|     31|    }
  731|      9|  }
  732|       |
  733|     16|  AutoArray<char> buf;
  734|     16|  try {
  735|     16|    buf.reset(new char[sizeof(T) * capacity]);
  736|     16|  } catch (const std::bad_alloc &) {
  737|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  738|      0|  }
  739|       |
  740|     16|  if (size_ > 0) {
  ------------------
  |  Branch (740:7): [True: 12, False: 4]
  ------------------
  741|     12|    T *src = reinterpret_cast<T *>(&buf_[0]);
  742|     12|    T *dest = reinterpret_cast<T *>(&buf[0]);
  743|     93|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (743:29): [True: 81, False: 12]
  ------------------
  744|     81|      new(&dest[i]) T(src[i]);
  745|     81|      src[i].~T();
  746|     81|    }
  747|     12|  }
  748|       |
  749|     16|  buf_.swap(&buf);
  750|     16|  capacity_ = capacity;
  751|     16|}
_ZN5Darts7Details9AutoArrayIcE5resetEPc:
  619|     47|  void reset(T *array = NULL) {
  620|     47|    AutoArray(array).swap(this);
  621|     47|  }
_ZN5Darts7Details9AutoArrayIcE4swapEPS2_:
  614|     94|  void swap(AutoArray *array) {
  615|     94|    T *temp = array_;
  616|     94|    array_ = array->array_;
  617|     94|    array->array_ = temp;
  618|     94|  }
_ZN5Darts7Details8AutoPoolIjE5clearEv:
  655|     18|  void clear() {
  656|     18|    resize(0);
  657|     18|    buf_.clear();
  658|     18|    size_ = 0;
  659|     18|    capacity_ = 0;
  660|     18|  }
_ZN5Darts7Details8AutoPoolIjE6resizeEm:
  680|     18|  void resize(std::size_t size) {
  681|  1.08k|    while (size_ > size) {
  ------------------
  |  Branch (681:12): [True: 1.06k, False: 18]
  ------------------
  682|  1.06k|      (*this)[--size_].~T();
  683|  1.06k|    }
  684|     18|    if (size > capacity_) {
  ------------------
  |  Branch (684:9): [True: 0, False: 18]
  ------------------
  685|      0|      resize_buf(size);
  686|      0|    }
  687|     18|    while (size_ < size) {
  ------------------
  |  Branch (687:12): [True: 0, False: 18]
  ------------------
  688|      0|      new(&(*this)[size_++]) T;
  689|      0|    }
  690|     18|  }
_ZN5Darts7Details9AutoArrayIjE5clearEv:
  608|      9|  void clear() {
  609|      9|    if (array_ != NULL) {
  ------------------
  |  Branch (609:9): [True: 2, False: 7]
  ------------------
  610|      2|      delete[] array_;
  611|       |      array_ = NULL;
  612|      2|    }
  613|      9|  }
_ZN5Darts7Details9AutoArrayIjE5resetEPj:
  619|      2|  void reset(T *array = NULL) {
  620|      2|    AutoArray(array).swap(this);
  621|      2|  }
_ZN5Darts7Details9AutoArrayIjE4swapEPS2_:
  614|      2|  void swap(AutoArray *array) {
  615|      2|    T *temp = array_;
  616|      2|    array_ = array->array_;
  617|      2|    array->array_ = temp;
  618|      2|  }
_ZNK5Darts7Details8AutoPoolIjE4sizeEv:
  651|    470|  std::size_t size() const {
  652|    470|    return size_;
  653|    470|  }
_ZN5Darts7Details9AutoArrayIjEixEm:
  600|      4|  T &operator[](std::size_t id) {
  601|      4|    return array_[id];
  602|      4|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgUnitEEixEm:
  641|    518|  const T &operator[](std::size_t id) const {
  642|    518|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  643|    518|  }
_ZNK5Darts7Details8AutoPoolIhEixEm:
  641|    473|  const T &operator[](std::size_t id) const {
  642|    473|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  643|    473|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgUnitEE4sizeEv:
  651|      8|  std::size_t size() const {
  652|      8|    return size_;
  653|      8|  }
_ZN5Darts7Details9AutoStackIjE4pushERKj:
  779|    197|  void push(const T &value) {
  780|    197|    pool_.push_back(value);
  781|    197|  }
_ZN5Darts7Details8AutoPoolIjE9push_backERKj:
  662|    197|  void push_back(const T &value) {
  663|    197|    append(value);
  664|    197|  }
_ZN5Darts7Details8AutoPoolIjE6resizeEmRKj:
  691|      1|  void resize(std::size_t size, const T &value) {
  692|      1|    while (size_ > size) {
  ------------------
  |  Branch (692:12): [True: 0, False: 1]
  ------------------
  693|      0|      (*this)[--size_].~T();
  694|      0|    }
  695|      1|    if (size > capacity_) {
  ------------------
  |  Branch (695:9): [True: 1, False: 0]
  ------------------
  696|      1|      resize_buf(size);
  697|      1|    }
  698|  1.02k|    while (size_ < size) {
  ------------------
  |  Branch (698:12): [True: 1.02k, False: 1]
  ------------------
  699|  1.02k|      new(&(*this)[size_++]) T(value);
  700|  1.02k|    }
  701|      1|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEEixEm:
  644|  1.46k|  T &operator[](std::size_t id) {
  645|  1.46k|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  646|  1.46k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEEixEm:
  644|    297|  T &operator[](std::size_t id) {
  645|    297|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  646|    297|  }
_ZN5Darts7Details8AutoPoolIhEixEm:
  644|    650|  T &operator[](std::size_t id) {
  645|    650|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  646|    650|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE5clearEv:
  655|      4|  void clear() {
  656|      4|    resize(0);
  657|      4|    buf_.clear();
  658|      4|    size_ = 0;
  659|      4|    capacity_ = 0;
  660|      4|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE6resizeEm:
  680|      4|  void resize(std::size_t size) {
  681|     40|    while (size_ > size) {
  ------------------
  |  Branch (681:12): [True: 36, False: 4]
  ------------------
  682|     36|      (*this)[--size_].~T();
  683|     36|    }
  684|      4|    if (size > capacity_) {
  ------------------
  |  Branch (684:9): [True: 0, False: 4]
  ------------------
  685|      0|      resize_buf(size);
  686|      0|    }
  687|      4|    while (size_ < size) {
  ------------------
  |  Branch (687:12): [True: 0, False: 4]
  ------------------
  688|      0|      new(&(*this)[size_++]) T;
  689|      0|    }
  690|      4|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE10resize_bufEm:
  722|      7|void AutoPool<T>::resize_buf(std::size_t size) {
  723|      7|  std::size_t capacity;
  724|      7|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (724:7): [True: 2, False: 5]
  ------------------
  725|      2|    capacity = size;
  726|      5|  } else {
  727|      5|    capacity = 1;
  728|     25|    while (capacity < size) {
  ------------------
  |  Branch (728:12): [True: 20, False: 5]
  ------------------
  729|     20|      capacity <<= 1;
  730|     20|    }
  731|      5|  }
  732|       |
  733|      7|  AutoArray<char> buf;
  734|      7|  try {
  735|      7|    buf.reset(new char[sizeof(T) * capacity]);
  736|      7|  } catch (const std::bad_alloc &) {
  737|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  738|      0|  }
  739|       |
  740|      7|  if (size_ > 0) {
  ------------------
  |  Branch (740:7): [True: 6, False: 1]
  ------------------
  741|      6|    T *src = reinterpret_cast<T *>(&buf_[0]);
  742|      6|    T *dest = reinterpret_cast<T *>(&buf[0]);
  743|     69|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (743:29): [True: 63, False: 6]
  ------------------
  744|     63|      new(&dest[i]) T(src[i]);
  745|     63|      src[i].~T();
  746|     63|    }
  747|      6|  }
  748|       |
  749|      7|  buf_.swap(&buf);
  750|      7|  capacity_ = capacity;
  751|      7|}
_ZN5Darts7Details9AutoStackIjE5clearEv:
  786|      8|  void clear() {
  787|      8|    pool_.clear();
  788|      8|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE5clearEv:
  655|      3|  void clear() {
  656|      3|    resize(0);
  657|      3|    buf_.clear();
  658|      3|    size_ = 0;
  659|      3|    capacity_ = 0;
  660|      3|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE6resizeEm:
  680|      3|  void resize(std::size_t size) {
  681|    102|    while (size_ > size) {
  ------------------
  |  Branch (681:12): [True: 99, False: 3]
  ------------------
  682|     99|      (*this)[--size_].~T();
  683|     99|    }
  684|      3|    if (size > capacity_) {
  ------------------
  |  Branch (684:9): [True: 0, False: 3]
  ------------------
  685|      0|      resize_buf(size);
  686|      0|    }
  687|      3|    while (size_ < size) {
  ------------------
  |  Branch (687:12): [True: 0, False: 3]
  ------------------
  688|      0|      new(&(*this)[size_++]) T;
  689|      0|    }
  690|      3|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE10resize_bufEm:
  722|      8|void AutoPool<T>::resize_buf(std::size_t size) {
  723|      8|  std::size_t capacity;
  724|      8|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (724:7): [True: 2, False: 6]
  ------------------
  725|      2|    capacity = size;
  726|      6|  } else {
  727|      6|    capacity = 1;
  728|     33|    while (capacity < size) {
  ------------------
  |  Branch (728:12): [True: 27, False: 6]
  ------------------
  729|     27|      capacity <<= 1;
  730|     27|    }
  731|      6|  }
  732|       |
  733|      8|  AutoArray<char> buf;
  734|      8|  try {
  735|      8|    buf.reset(new char[sizeof(T) * capacity]);
  736|      8|  } catch (const std::bad_alloc &) {
  737|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  738|      0|  }
  739|       |
  740|      8|  if (size_ > 0) {
  ------------------
  |  Branch (740:7): [True: 7, False: 1]
  ------------------
  741|      7|    T *src = reinterpret_cast<T *>(&buf_[0]);
  742|      7|    T *dest = reinterpret_cast<T *>(&buf[0]);
  743|    134|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (743:29): [True: 127, False: 7]
  ------------------
  744|    127|      new(&dest[i]) T(src[i]);
  745|    127|      src[i].~T();
  746|    127|    }
  747|      7|  }
  748|       |
  749|      8|  buf_.swap(&buf);
  750|      8|  capacity_ = capacity;
  751|      8|}
_ZN5Darts7Details8AutoPoolIhE5clearEv:
  655|      6|  void clear() {
  656|      6|    resize(0);
  657|      6|    buf_.clear();
  658|      6|    size_ = 0;
  659|      6|    capacity_ = 0;
  660|      6|  }
_ZN5Darts7Details9AutoStackIjE3topEv:
  768|    282|  T &top() {
  769|    282|    return pool_[size() - 1];
  770|    282|  }
_ZNK5Darts7Details9AutoStackIjE4sizeEv:
  775|    282|  std::size_t size() const {
  776|    282|    return pool_.size();
  777|    282|  }
_ZN5Darts7Details9AutoStackIjE3popEv:
  782|    162|  void pop() {
  783|    162|    pool_.pop_back();
  784|    162|  }
_ZN5Darts7Details8AutoPoolIjE8pop_backEv:
  665|    162|  void pop_back() {
  666|    162|    (*this)[--size_].~T();
  667|    162|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgNodeEEixEm:
  641|    298|  const T &operator[](std::size_t id) const {
  642|    298|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  643|    298|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE6appendEv:
  669|     99|  void append() {
  670|     99|    if (size_ == capacity_)
  ------------------
  |  Branch (670:9): [True: 8, False: 91]
  ------------------
  671|      8|      resize_buf(size_ + 1);
  672|     99|    new(&(*this)[size_++]) T;
  673|     99|  }
_ZN5Darts7Details8AutoPoolIhE6appendEv:
  669|     99|  void append() {
  670|     99|    if (size_ == capacity_)
  ------------------
  |  Branch (670:9): [True: 8, False: 91]
  ------------------
  671|      8|      resize_buf(size_ + 1);
  672|     99|    new(&(*this)[size_++]) T;
  673|     99|  }
_ZN5Darts7Details8AutoPoolIhE10resize_bufEm:
  722|     14|void AutoPool<T>::resize_buf(std::size_t size) {
  723|     14|  std::size_t capacity;
  724|     14|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (724:7): [True: 4, False: 10]
  ------------------
  725|      4|    capacity = size;
  726|     10|  } else {
  727|     10|    capacity = 1;
  728|     51|    while (capacity < size) {
  ------------------
  |  Branch (728:12): [True: 41, False: 10]
  ------------------
  729|     41|      capacity <<= 1;
  730|     41|    }
  731|     10|  }
  732|       |
  733|     14|  AutoArray<char> buf;
  734|     14|  try {
  735|     14|    buf.reset(new char[sizeof(T) * capacity]);
  736|     14|  } catch (const std::bad_alloc &) {
  737|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  738|      0|  }
  739|       |
  740|     14|  if (size_ > 0) {
  ------------------
  |  Branch (740:7): [True: 12, False: 2]
  ------------------
  741|     12|    T *src = reinterpret_cast<T *>(&buf_[0]);
  742|     12|    T *dest = reinterpret_cast<T *>(&buf[0]);
  743|    170|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (743:29): [True: 158, False: 12]
  ------------------
  744|    158|      new(&dest[i]) T(src[i]);
  745|    158|      src[i].~T();
  746|    158|    }
  747|     12|  }
  748|       |
  749|     14|  buf_.swap(&buf);
  750|     14|  capacity_ = capacity;
  751|     14|}
_ZNK5Darts7Details9AutoStackIjE5emptyEv:
  772|     99|  bool empty() const {
  773|     99|    return pool_.empty();
  774|     99|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgNodeEE4sizeEv:
  651|     36|  std::size_t size() const {
  652|     36|    return size_;
  653|     36|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE6appendEv:
  669|     36|  void append() {
  670|     36|    if (size_ == capacity_)
  ------------------
  |  Branch (670:9): [True: 7, False: 29]
  ------------------
  671|      7|      resize_buf(size_ + 1);
  672|     36|    new(&(*this)[size_++]) T;
  673|     36|  }
_ZNK5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE4sizeEv:
  651|    580|  std::size_t size() const {
  652|    580|    return size_;
  653|    580|  }
_ZNK5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEixEm:
  597|    249|  const T &operator[](std::size_t id) const {
  598|    249|    return array_[id];
  599|    249|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEixEm:
  600|  2.83k|  T &operator[](std::size_t id) {
  601|  2.83k|    return array_[id];
  602|  2.83k|  }
_ZNK5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEixEm:
  641|    256|  const T &operator[](std::size_t id) const {
  642|    256|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  643|    256|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE5clearEv:
  655|      2|  void clear() {
  656|      2|    resize(0);
  657|      2|    buf_.clear();
  658|      2|    size_ = 0;
  659|      2|    capacity_ = 0;
  660|      2|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE5clearEv:
  608|      4|  void clear() {
  609|      4|    if (array_ != NULL) {
  ------------------
  |  Branch (609:9): [True: 1, False: 3]
  ------------------
  610|      1|      delete[] array_;
  611|       |      array_ = NULL;
  612|      1|    }
  613|      4|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE7reserveEm:
  703|      1|  void reserve(std::size_t size) {
  704|      1|    if (size > capacity_) {
  ------------------
  |  Branch (704:9): [True: 1, False: 0]
  ------------------
  705|      1|      resize_buf(size);
  706|      1|    }
  707|      1|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE10resize_bufEm:
  722|      2|void AutoPool<T>::resize_buf(std::size_t size) {
  723|      2|  std::size_t capacity;
  724|      2|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (724:7): [True: 2, False: 0]
  ------------------
  725|      2|    capacity = size;
  726|      2|  } else {
  727|      0|    capacity = 1;
  728|      0|    while (capacity < size) {
  ------------------
  |  Branch (728:12): [True: 0, False: 0]
  ------------------
  729|      0|      capacity <<= 1;
  730|      0|    }
  731|      0|  }
  732|       |
  733|      2|  AutoArray<char> buf;
  734|      2|  try {
  735|      2|    buf.reset(new char[sizeof(T) * capacity]);
  736|      2|  } catch (const std::bad_alloc &) {
  737|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  738|      0|  }
  739|       |
  740|      2|  if (size_ > 0) {
  ------------------
  |  Branch (740:7): [True: 0, False: 2]
  ------------------
  741|      0|    T *src = reinterpret_cast<T *>(&buf_[0]);
  742|      0|    T *dest = reinterpret_cast<T *>(&buf[0]);
  743|      0|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (743:29): [True: 0, False: 0]
  ------------------
  744|      0|      new(&dest[i]) T(src[i]);
  745|      0|      src[i].~T();
  746|      0|    }
  747|      0|  }
  748|       |
  749|      2|  buf_.swap(&buf);
  750|      2|  capacity_ = capacity;
  751|      2|}
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE5resetEPS2_:
  619|      1|  void reset(T *array = NULL) {
  620|      1|    AutoArray(array).swap(this);
  621|      1|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE4swapEPS3_:
  614|      1|  void swap(AutoArray *array) {
  615|      1|    T *temp = array_;
  616|      1|    array_ = array->array_;
  617|      1|    array->array_ = temp;
  618|      1|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEixEm:
  644|    868|  T &operator[](std::size_t id) {
  645|    868|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  646|    868|  }
_ZN5Darts7Details8AutoPoolIhE6resizeEm:
  680|     66|  void resize(std::size_t size) {
  681|    263|    while (size_ > size) {
  ------------------
  |  Branch (681:12): [True: 197, False: 66]
  ------------------
  682|    197|      (*this)[--size_].~T();
  683|    197|    }
  684|     66|    if (size > capacity_) {
  ------------------
  |  Branch (684:9): [True: 0, False: 66]
  ------------------
  685|      0|      resize_buf(size);
  686|      0|    }
  687|     66|    while (size_ < size) {
  ------------------
  |  Branch (687:12): [True: 0, False: 66]
  ------------------
  688|      0|      new(&(*this)[size_++]) T;
  689|      0|    }
  690|     66|  }
_ZN5Darts7Details8AutoPoolIhE6appendERKh:
  674|     98|  void append(const T &value) {
  675|     98|    if (size_ == capacity_)
  ------------------
  |  Branch (675:9): [True: 6, False: 92]
  ------------------
  676|      6|      resize_buf(size_ + 1);
  677|     98|    new(&(*this)[size_++]) T(value);
  678|     98|  }
_ZNK5Darts7Details8AutoPoolIhE4sizeEv:
  651|    267|  std::size_t size() const {
  652|    267|    return size_;
  653|    267|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE6resizeEm:
  680|      3|  void resize(std::size_t size) {
  681|    259|    while (size_ > size) {
  ------------------
  |  Branch (681:12): [True: 256, False: 3]
  ------------------
  682|    256|      (*this)[--size_].~T();
  683|    256|    }
  684|      3|    if (size > capacity_) {
  ------------------
  |  Branch (684:9): [True: 1, False: 2]
  ------------------
  685|      1|      resize_buf(size);
  686|      1|    }
  687|    259|    while (size_ < size) {
  ------------------
  |  Branch (687:12): [True: 256, False: 3]
  ------------------
  688|    256|      new(&(*this)[size_++]) T;
  689|    256|    }
  690|      3|  }
_ZN5Darts15DoubleArrayImplIvvivE5clearEv:
  194|      1|  void clear() {
  195|      1|    size_ = 0;
  196|      1|    array_ = NULL;
  197|      1|    if (buf_ != NULL) {
  ------------------
  |  Branch (197:9): [True: 0, False: 1]
  ------------------
  198|      0|      delete[] buf_;
  199|       |      buf_ = NULL;
  200|      0|    }
  201|      1|  }
_ZN5Darts15DoubleArrayImplIvvivEC2Ev:
  139|      1|  DoubleArrayImpl() : size_(0), array_(NULL), buf_(NULL) {}
_ZNK5Darts15DoubleArrayImplIvvivE18commonPrefixSearchINS1_16result_pair_typeEEEmPKcPT_mmm:
  505|     39|    std::size_t length, std::size_t node_pos) const {
  506|     39|  std::size_t num_results = 0;
  507|       |
  508|     39|  unit_type unit = array_[node_pos];
  509|     39|  node_pos ^= unit.offset();
  510|     39|  if (length != 0) {
  ------------------
  |  Branch (510:7): [True: 39, False: 0]
  ------------------
  511|    132|    for (std::size_t i = 0; i < length; ++i) {
  ------------------
  |  Branch (511:29): [True: 93, False: 39]
  ------------------
  512|     93|      node_pos ^= static_cast<uchar_type>(key[i]);
  513|     93|      unit = array_[node_pos];
  514|     93|      if (unit.label() != static_cast<uchar_type>(key[i])) {
  ------------------
  |  Branch (514:11): [True: 0, False: 93]
  ------------------
  515|      0|        return num_results;
  516|      0|      }
  517|       |
  518|     93|      node_pos ^= unit.offset();
  519|     93|      if (unit.has_leaf()) {
  ------------------
  |  Branch (519:11): [True: 58, False: 35]
  ------------------
  520|     58|        if (num_results < max_num_results) {
  ------------------
  |  Branch (520:13): [True: 58, False: 0]
  ------------------
  521|     58|          set_result(&results[num_results], static_cast<value_type>(
  522|     58|              array_[node_pos].value()), i + 1);
  523|     58|        }
  524|     58|        ++num_results;
  525|     58|      }
  526|     93|    }
  527|     39|  } else {
  528|      0|    for ( ; key[length] != '\0'; ++length) {
  ------------------
  |  Branch (528:13): [True: 0, False: 0]
  ------------------
  529|      0|      node_pos ^= static_cast<uchar_type>(key[length]);
  530|      0|      unit = array_[node_pos];
  531|      0|      if (unit.label() != static_cast<uchar_type>(key[length])) {
  ------------------
  |  Branch (531:11): [True: 0, False: 0]
  ------------------
  532|      0|        return num_results;
  533|      0|      }
  534|       |
  535|      0|      node_pos ^= unit.offset();
  536|      0|      if (unit.has_leaf()) {
  ------------------
  |  Branch (536:11): [True: 0, False: 0]
  ------------------
  537|      0|        if (num_results < max_num_results) {
  ------------------
  |  Branch (537:13): [True: 0, False: 0]
  ------------------
  538|      0|          set_result(&results[num_results], static_cast<value_type>(
  539|      0|              array_[node_pos].value()), length + 1);
  540|      0|        }
  541|      0|        ++num_results;
  542|      0|      }
  543|      0|    }
  544|      0|  }
  545|       |
  546|     39|  return num_results;
  547|     39|}
_ZNK5Darts15DoubleArrayImplIvvivE10set_resultEPNS1_16result_pair_typeEim:
  160|     58|      value_type value, std::size_t length) const {
  161|     58|    result->value = value;
  162|     58|    result->length = length;
  163|     58|  }
_ZN5Darts15DoubleArrayImplIvvivE5buildEmPKPKcPKmPKiPFimmE:
 1930|      1|    const value_type *values, Details::progress_func_type progress_func) {
 1931|      1|  Details::Keyset<value_type> keyset(num_keys, keys, lengths, values);
 1932|       |
 1933|      1|  Details::DoubleArrayBuilder builder(progress_func);
 1934|      1|  builder.build(keyset);
 1935|       |
 1936|      1|  std::size_t size = 0;
 1937|      1|  unit_type *buf = NULL;
 1938|      1|  builder.copy(&size, &buf);
 1939|       |
 1940|      1|  clear();
 1941|       |
 1942|      1|  size_ = size;
 1943|      1|  array_ = buf;
 1944|      1|  buf_ = buf;
 1945|       |
 1946|      1|  if (progress_func != NULL) {
  ------------------
  |  Branch (1946:7): [True: 0, False: 1]
  ------------------
 1947|      0|    progress_func(num_keys + 1, num_keys + 1);
 1948|      0|  }
 1949|       |
 1950|      1|  return 0;
 1951|      1|}
_ZN5Darts7Details6KeysetIiEC2EmPKPKcPKmPKi:
  895|      1|      num_keys_(num_keys), keys_(keys), lengths_(lengths), values_(values) {}
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEC2Ev:
  638|      1|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoArrayIcEC2EPc:
  592|    103|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEC2EPS2_:
  592|      2|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details8AutoPoolIhEC2Ev:
  638|      2|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoArrayIjEC2EPj:
  592|      4|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details8AutoPoolIhED2Ev:
  639|      2|  ~AutoPool() { clear(); }
_ZN5Darts7Details9AutoArrayIcED2Ev:
  593|    103|  ~AutoArray() {
  594|    103|    clear();
  595|    103|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEED2Ev:
  593|      2|  ~AutoArray() {
  594|      2|    clear();
  595|      2|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEED2Ev:
  639|      1|  ~AutoPool() { clear(); }
_ZN5Darts7Details18DoubleArrayBuilder5buildIiEEvRKNS0_6KeysetIT_EE:
 1554|      1|void DoubleArrayBuilder::build(const Keyset<T> &keyset) {
 1555|      1|  if (keyset.has_values()) {
  ------------------
  |  Branch (1555:7): [True: 1, False: 0]
  ------------------
 1556|      1|    Details::DawgBuilder dawg_builder;
 1557|      1|    build_dawg(keyset, &dawg_builder);
 1558|      1|    build_from_dawg(dawg_builder);
 1559|      1|    dawg_builder.clear();
 1560|      1|  } else {
 1561|      0|    build_from_keyset(keyset);
 1562|      0|  }
 1563|      1|}
_ZNK5Darts7Details6KeysetIiE10has_valuesEv:
  923|     40|  bool has_values() const {
  924|       |    return values_ != NULL;
  925|     40|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEEC2Ev:
  638|      1|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEEC2Ev:
  638|      1|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details8AutoPoolIjEC2Ev:
  638|      4|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoStackIjEC2Ev:
  760|      2|  AutoStack() : pool_() {}
_ZN5Darts7Details9AutoStackIjED2Ev:
  761|      2|  ~AutoStack() {
  762|      2|    clear();
  763|      2|  }
_ZN5Darts7Details8AutoPoolIjED2Ev:
  639|      4|  ~AutoPool() { clear(); }
_ZN5Darts7Details9AutoArrayIjED2Ev:
  593|      4|  ~AutoArray() {
  594|      4|    clear();
  595|      4|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEED2Ev:
  639|      1|  ~AutoPool() { clear(); }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEED2Ev:
  639|      1|  ~AutoPool() { clear(); }
_ZN5Darts7Details18DoubleArrayBuilder10build_dawgIiEEvRKNS0_6KeysetIT_EEPNS0_11DawgBuilderE:
 1589|      1|    DawgBuilder *dawg_builder) {
 1590|      1|  dawg_builder->init();
 1591|     40|  for (std::size_t i = 0; i < keyset.num_keys(); ++i) {
  ------------------
  |  Branch (1591:27): [True: 39, False: 1]
  ------------------
 1592|     39|    dawg_builder->insert(keyset.keys(i), keyset.lengths(i), keyset.values(i));
 1593|     39|    if (progress_func_ != NULL) {
  ------------------
  |  Branch (1593:9): [True: 0, False: 39]
  ------------------
 1594|      0|      progress_func_(i + 1, keyset.num_keys() + 1);
 1595|      0|    }
 1596|     39|  }
 1597|      1|  dawg_builder->finish();
 1598|      1|}
_ZNK5Darts7Details6KeysetIiE8num_keysEv:
  897|     40|  std::size_t num_keys() const {
  898|     40|    return num_keys_;
  899|     40|  }
_ZNK5Darts7Details6KeysetIiE4keysEm:
  900|     39|  const char_type *keys(std::size_t id) const {
  901|     39|    return keys_[id];
  902|     39|  }
_ZNK5Darts7Details6KeysetIiE7lengthsEm:
  912|     39|  std::size_t lengths(std::size_t id) const {
  913|     39|    if (has_lengths()) {
  ------------------
  |  Branch (913:9): [True: 39, False: 0]
  ------------------
  914|     39|      return lengths_[id];
  915|     39|    }
  916|      0|    std::size_t length = 0;
  917|      0|    while (keys_[id][length] != '\0') {
  ------------------
  |  Branch (917:12): [True: 0, False: 0]
  ------------------
  918|      0|      ++length;
  919|      0|    }
  920|      0|    return length;
  921|     39|  }
_ZNK5Darts7Details6KeysetIiE11has_lengthsEv:
  909|     39|  bool has_lengths() const {
  910|       |    return lengths_ != NULL;
  911|     39|  }
_ZNK5Darts7Details6KeysetIiE6valuesEm:
  926|     39|  const value_type values(std::size_t id) const {
  927|     39|    if (has_values()) {
  ------------------
  |  Branch (927:9): [True: 39, False: 0]
  ------------------
  928|     39|      return static_cast<value_type>(values_[id]);
  929|     39|    }
  930|      0|    return static_cast<value_type>(id);
  931|     39|  }
_ZNK5Darts15DoubleArrayImplIvvivE16exactMatchSearchIiEEvPKcRT_mm:
  273|      1|      std::size_t length = 0, std::size_t node_pos = 0) const {
  274|      1|    result = exactMatchSearch<U>(key, length, node_pos);
  275|      1|  }
_ZNK5Darts15DoubleArrayImplIvvivE16exactMatchSearchIiEET_PKcmm:
  470|      1|    std::size_t length, std::size_t node_pos) const {
  471|      1|  U result;
  472|      1|  set_result(&result, static_cast<value_type>(-1), 0);
  473|       |
  474|      1|  unit_type unit = array_[node_pos];
  475|      1|  if (length != 0) {
  ------------------
  |  Branch (475:7): [True: 1, False: 0]
  ------------------
  476|      1|    for (std::size_t i = 0; i < length; ++i) {
  ------------------
  |  Branch (476:29): [True: 1, False: 0]
  ------------------
  477|      1|      node_pos ^= unit.offset() ^ static_cast<uchar_type>(key[i]);
  478|      1|      unit = array_[node_pos];
  479|      1|      if (unit.label() != static_cast<uchar_type>(key[i])) {
  ------------------
  |  Branch (479:11): [True: 1, False: 0]
  ------------------
  480|      1|        return result;
  481|      1|      }
  482|      1|    }
  483|      1|  } else {
  484|      0|    for ( ; key[length] != '\0'; ++length) {
  ------------------
  |  Branch (484:13): [True: 0, False: 0]
  ------------------
  485|      0|      node_pos ^= unit.offset() ^ static_cast<uchar_type>(key[length]);
  486|      0|      unit = array_[node_pos];
  487|      0|      if (unit.label() != static_cast<uchar_type>(key[length])) {
  ------------------
  |  Branch (487:11): [True: 0, False: 0]
  ------------------
  488|      0|        return result;
  489|      0|      }
  490|      0|    }
  491|      0|  }
  492|       |
  493|      0|  if (!unit.has_leaf()) {
  ------------------
  |  Branch (493:7): [True: 0, False: 0]
  ------------------
  494|      0|    return result;
  495|      0|  }
  496|      0|  unit = array_[node_pos ^ unit.offset()];
  497|      0|  set_result(&result, static_cast<value_type>(unit.value()), length);
  498|      0|  return result;
  499|      0|}
_ZNK5Darts15DoubleArrayImplIvvivE10set_resultEPiim:
  155|      1|  void set_result(value_type *result, value_type value, std::size_t) const {
  156|      1|    *result = value;
  157|      1|  }