_ZN6google8protobuf5Arena6CreateINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_:
  274|      4|  PROTOBUF_NDEBUG_INLINE static T* Create(Arena* arena, Args&&... args) {
  275|      4|    if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) {
  ------------------
  |  |  551|      4|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 4, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  276|      4|      return new T(std::forward<Args>(args)...);
  277|      4|    }
  278|      0|    return new (arena->AllocateInternal<T>()) T(std::forward<Args>(args)...);
  279|      4|  }
_ZN6google8protobuf5Arena21CreateMessageInternalINS0_30DescriptorProto_ExtensionRangeEEEPT_PS1_:
  556|     18|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  557|     18|    static_assert(
  558|     18|        is_arena_constructable<T>::value,
  559|     18|        "CreateMessage can only construct types that are ArenaConstructable");
  560|     18|    if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) {
  ------------------
  |  |  551|     18|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 18, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 18, False: 0]
  |  |  ------------------
  ------------------
  561|       |      // Generated arena constructor T(Arena*) is protected. Call via
  562|       |      // InternalHelper.
  563|     18|      return InternalHelper<T>::New();
  564|     18|    } else {
  565|      0|      return arena->DoCreateMessage<T>();
  566|      0|    }
  567|     18|  }
_ZN6google8protobuf5Arena14InternalHelperINS0_30DescriptorProto_ExtensionRangeEE3NewEv:
  492|     18|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  493|     18|      return new T(nullptr);
  494|     18|    }
_ZN6google8protobuf5Arena21CreateMessageInternalINS0_29DescriptorProto_ReservedRangeEEEPT_PS1_:
  556|     16|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  557|     16|    static_assert(
  558|     16|        is_arena_constructable<T>::value,
  559|     16|        "CreateMessage can only construct types that are ArenaConstructable");
  560|     16|    if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) {
  ------------------
  |  |  551|     16|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 16, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 16, False: 0]
  |  |  ------------------
  ------------------
  561|       |      // Generated arena constructor T(Arena*) is protected. Call via
  562|       |      // InternalHelper.
  563|     16|      return InternalHelper<T>::New();
  564|     16|    } else {
  565|      0|      return arena->DoCreateMessage<T>();
  566|      0|    }
  567|     16|  }
_ZN6google8protobuf5Arena14InternalHelperINS0_29DescriptorProto_ReservedRangeEE3NewEv:
  492|     16|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  493|     16|      return new T(nullptr);
  494|     16|    }
_ZN6google8protobuf5Arena21CreateMessageInternalINS0_15DescriptorProtoEEEPT_PS1_:
  556|     96|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  557|     96|    static_assert(
  558|     96|        is_arena_constructable<T>::value,
  559|     96|        "CreateMessage can only construct types that are ArenaConstructable");
  560|     96|    if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) {
  ------------------
  |  |  551|     96|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 96, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 96, False: 0]
  |  |  ------------------
  ------------------
  561|       |      // Generated arena constructor T(Arena*) is protected. Call via
  562|       |      // InternalHelper.
  563|     96|      return InternalHelper<T>::New();
  564|     96|    } else {
  565|      0|      return arena->DoCreateMessage<T>();
  566|      0|    }
  567|     96|  }
_ZN6google8protobuf5Arena14InternalHelperINS0_15DescriptorProtoEE3NewEv:
  492|     96|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  493|     96|      return new T(nullptr);
  494|     96|    }
_ZN6google8protobuf5Arena21CreateMessageInternalINS0_20FieldDescriptorProtoEEEPT_PS1_:
  556|    386|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  557|    386|    static_assert(
  558|    386|        is_arena_constructable<T>::value,
  559|    386|        "CreateMessage can only construct types that are ArenaConstructable");
  560|    386|    if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) {
  ------------------
  |  |  551|    386|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 386, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 386, False: 0]
  |  |  ------------------
  ------------------
  561|       |      // Generated arena constructor T(Arena*) is protected. Call via
  562|       |      // InternalHelper.
  563|    386|      return InternalHelper<T>::New();
  564|    386|    } else {
  565|      0|      return arena->DoCreateMessage<T>();
  566|      0|    }
  567|    386|  }
_ZN6google8protobuf5Arena14InternalHelperINS0_20FieldDescriptorProtoEE3NewEv:
  492|    386|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  493|    386|      return new T(nullptr);
  494|    386|    }
_ZN6google8protobuf5Arena21CreateMessageInternalINS0_20OneofDescriptorProtoEEEPT_PS1_:
  556|      2|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  557|      2|    static_assert(
  558|      2|        is_arena_constructable<T>::value,
  559|      2|        "CreateMessage can only construct types that are ArenaConstructable");
  560|      2|    if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) {
  ------------------
  |  |  551|      2|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 2, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  561|       |      // Generated arena constructor T(Arena*) is protected. Call via
  562|       |      // InternalHelper.
  563|      2|      return InternalHelper<T>::New();
  564|      2|    } else {
  565|      0|      return arena->DoCreateMessage<T>();
  566|      0|    }
  567|      2|  }
_ZN6google8protobuf5Arena14InternalHelperINS0_20OneofDescriptorProtoEE3NewEv:
  492|      2|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  493|      2|      return new T(nullptr);
  494|      2|    }
_ZN6google8protobuf5Arena21CreateMessageInternalINS0_19EnumDescriptorProtoEEEPT_PS1_:
  556|     28|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  557|     28|    static_assert(
  558|     28|        is_arena_constructable<T>::value,
  559|     28|        "CreateMessage can only construct types that are ArenaConstructable");
  560|     28|    if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) {
  ------------------
  |  |  551|     28|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 28, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 28, False: 0]
  |  |  ------------------
  ------------------
  561|       |      // Generated arena constructor T(Arena*) is protected. Call via
  562|       |      // InternalHelper.
  563|     28|      return InternalHelper<T>::New();
  564|     28|    } else {
  565|      0|      return arena->DoCreateMessage<T>();
  566|      0|    }
  567|     28|  }
_ZN6google8protobuf5Arena14InternalHelperINS0_19EnumDescriptorProtoEE3NewEv:
  492|     28|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  493|     28|      return new T(nullptr);
  494|     28|    }
_ZN6google8protobuf5Arena21CreateMessageInternalINS0_24EnumValueDescriptorProtoEEEPT_PS1_:
  556|    156|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  557|    156|    static_assert(
  558|    156|        is_arena_constructable<T>::value,
  559|    156|        "CreateMessage can only construct types that are ArenaConstructable");
  560|    156|    if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) {
  ------------------
  |  |  551|    156|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 156, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 156, False: 0]
  |  |  ------------------
  ------------------
  561|       |      // Generated arena constructor T(Arena*) is protected. Call via
  562|       |      // InternalHelper.
  563|    156|      return InternalHelper<T>::New();
  564|    156|    } else {
  565|      0|      return arena->DoCreateMessage<T>();
  566|      0|    }
  567|    156|  }
_ZN6google8protobuf5Arena14InternalHelperINS0_24EnumValueDescriptorProtoEE3NewEv:
  492|    156|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  493|    156|      return new T(nullptr);
  494|    156|    }
_ZN6google8protobuf5Arena21CreateMessageInternalINS0_11FileOptionsEEEPT_PS1_:
  556|     12|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  557|     12|    static_assert(
  558|     12|        is_arena_constructable<T>::value,
  559|     12|        "CreateMessage can only construct types that are ArenaConstructable");
  560|     12|    if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) {
  ------------------
  |  |  551|     12|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 12, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 12, False: 0]
  |  |  ------------------
  ------------------
  561|       |      // Generated arena constructor T(Arena*) is protected. Call via
  562|       |      // InternalHelper.
  563|     12|      return InternalHelper<T>::New();
  564|     12|    } else {
  565|      0|      return arena->DoCreateMessage<T>();
  566|      0|    }
  567|     12|  }
_ZN6google8protobuf5Arena14InternalHelperINS0_11FileOptionsEE3NewEv:
  492|     12|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  493|     12|      return new T(nullptr);
  494|     12|    }
_ZN6google8protobuf5Arena21CreateMessageInternalINS0_14MessageOptionsEEEPT_PS1_:
  556|      2|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  557|      2|    static_assert(
  558|      2|        is_arena_constructable<T>::value,
  559|      2|        "CreateMessage can only construct types that are ArenaConstructable");
  560|      2|    if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) {
  ------------------
  |  |  551|      2|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 2, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  561|       |      // Generated arena constructor T(Arena*) is protected. Call via
  562|       |      // InternalHelper.
  563|      2|      return InternalHelper<T>::New();
  564|      2|    } else {
  565|      0|      return arena->DoCreateMessage<T>();
  566|      0|    }
  567|      2|  }
_ZN6google8protobuf5Arena14InternalHelperINS0_14MessageOptionsEE3NewEv:
  492|      2|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  493|      2|      return new T(nullptr);
  494|      2|    }
_ZN6google8protobuf5Arena21CreateMessageInternalINS0_12FieldOptionsEEEPT_PS1_:
  556|     18|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  557|     18|    static_assert(
  558|     18|        is_arena_constructable<T>::value,
  559|     18|        "CreateMessage can only construct types that are ArenaConstructable");
  560|     18|    if (PROTOBUF_PREDICT_FALSE(arena == nullptr)) {
  ------------------
  |  |  551|     18|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 18, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 18, False: 0]
  |  |  ------------------
  ------------------
  561|       |      // Generated arena constructor T(Arena*) is protected. Call via
  562|       |      // InternalHelper.
  563|     18|      return InternalHelper<T>::New();
  564|     18|    } else {
  565|      0|      return arena->DoCreateMessage<T>();
  566|      0|    }
  567|     18|  }
_ZN6google8protobuf5Arena14InternalHelperINS0_12FieldOptionsEE3NewEv:
  492|     18|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  493|     18|      return new T(nullptr);
  494|     18|    }

_ZN6google8protobuf8internal15TaggedStringPtrC2EPNS1_21ExplicitlyConstructedINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELm8EEE:
  133|  2.38k|      : ptr_(ptr) {}
_ZN6google8protobuf8internal15TaggedStringPtr12SetAllocatedEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  144|    954|  inline std::string* SetAllocated(std::string* p) {
  145|    954|    return TagAs(kAllocated, p);
  146|    954|  }
_ZNK6google8protobuf8internal15TaggedStringPtr9IsMutableEv:
  163|    954|  inline bool IsMutable() const { return as_int() & kMutableBit; }
_ZNK6google8protobuf8internal15TaggedStringPtr14GetIfAllocatedEv:
  170|  2.38k|  inline std::string* GetIfAllocated() const {
  171|  2.38k|    auto allocated = as_int() ^ kAllocated;
  172|  2.38k|    if (allocated & kMask) return nullptr;
  ------------------
  |  Branch (172:9): [True: 1.42k, False: 954]
  ------------------
  173|       |
  174|    954|    auto ptr = reinterpret_cast<std::string*>(allocated);
  175|    954|    PROTOBUF_ASSUME(ptr != nullptr);
  ------------------
  |  | 1101|    954|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  176|    954|    return ptr;
  177|  2.38k|  }
_ZNK6google8protobuf8internal15TaggedStringPtr3GetEv:
  189|    224|  inline std::string* Get() const {
  190|    224|    return reinterpret_cast<std::string*>(as_int() & ~kMask);
  191|    224|  }
_ZN6google8protobuf8internal15TaggedStringPtr14assert_alignedEPKv:
  199|    954|  static inline void assert_aligned(const void* p) {
  200|    954|    ABSL_DCHECK_EQ(reinterpret_cast<uintptr_t>(p) & kMask, 0UL);
  ------------------
  |  |   70|    954|  ABSL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   86|    954|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|    954|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    954|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  201|    954|  }
_ZN6google8protobuf8internal15TaggedStringPtr5TagAsENS2_4TypeEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
  203|    954|  inline std::string* TagAs(Type type, std::string* p) {
  204|    954|    ABSL_DCHECK(p != nullptr);
  ------------------
  |  |   43|    954|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|    954|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|    954|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|    954|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|    954|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|    954|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  205|    954|    assert_aligned(p);
  206|    954|    ptr_ = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(p) | type);
  207|    954|    return p;
  208|    954|  }
_ZNK6google8protobuf8internal15TaggedStringPtr6as_intEv:
  210|  3.55k|  uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
_ZNK6google8protobuf8internal14ArenaStringPtr3GetEv:
  299|    224|  PROTOBUF_NDEBUG_INLINE const std::string& Get() const {
  300|       |    // Unconditionally mask away the tag.
  301|    224|    return *tagged_ptr_.Get();
  302|    224|  }
_ZN6google8protobuf8internal14ArenaStringPtr11InitDefaultEv:
  395|  2.38k|inline void ArenaStringPtr::InitDefault() {
  396|  2.38k|  tagged_ptr_ = TaggedStringPtr(&fixed_address_empty_string);
  397|  2.38k|}
_ZN6google8protobuf8internal14ArenaStringPtr9NewStringIJEEEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaEDpOT_:
  361|    954|  inline std::string* NewString(Arena* arena, Args&&... args) {
  362|    954|    if (arena == nullptr) {
  ------------------
  |  Branch (362:9): [True: 954, False: 0]
  ------------------
  363|    954|      auto* s = new std::string(std::forward<Args>(args)...);
  364|    954|      return tagged_ptr_.SetAllocated(s);
  365|    954|    } else {
  366|      0|      auto* s = Arena::Create<std::string>(arena, std::forward<Args>(args)...);
  367|      0|      return tagged_ptr_.SetMutableArena(s);
  368|      0|    }
  369|    954|  }

_ZN6google8protobuf8internal13little_endian6ToHostEt:
  114|  2.63k|inline uint16_t ToHost(uint16_t value) {
  115|       |#if defined(PROTOBUF_BIG_ENDIAN)
  116|       |  return BSwap16(value);
  117|       |#else
  118|  2.63k|  return value;
  119|  2.63k|#endif
  120|  2.63k|}

_ZN6google8protobuf8internal21ExplicitlyConstructedINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELm8EE16DefaultConstructEv:
   63|      2|  void DefaultConstruct() { new (&union_) T(); }
_ZN6google8protobuf8internal21ExplicitlyConstructedINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELm8EE11get_mutableEv:
   73|      2|  T* get_mutable() { return reinterpret_cast<T*>(&union_); }

_ZN6google8protobuf8internal12ExtensionSetC2ENS1_16ArenaInitializedEPNS0_5ArenaE:
  189|     32|  ExtensionSet(ArenaInitialized, Arena* arena) : ExtensionSet(arena) {}
_ZNK6google8protobuf8internal12ExtensionSet8is_largeEv:
  713|     96|  bool is_large() const { return static_cast<int16_t>(flat_size_) < 0; }
_ZN6google8protobuf8internal12ExtensionSet10flat_beginEv:
  890|     32|  KeyValue* flat_begin() {
  891|     32|    assert(!is_large());
  892|     32|    return map_.flat;
  893|     32|  }
_ZNK6google8protobuf8internal12ExtensionSet10flat_beginEv:
  894|     32|  const KeyValue* flat_begin() const {
  895|     32|    assert(!is_large());
  896|     32|    return map_.flat;
  897|     32|  }
_ZN6google8protobuf8internal12ExtensionSet8flat_endEv:
  898|     32|  KeyValue* flat_end() {
  899|     32|    assert(!is_large());
  900|     32|    return map_.flat + flat_size_;
  901|     32|  }
_ZNK6google8protobuf8internal12ExtensionSet8flat_endEv:
  902|     32|  const KeyValue* flat_end() const {
  903|     32|    assert(!is_large());
  904|     32|    return map_.flat + flat_size_;
  905|     32|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIZNS2_D1EvE3$_0EET_S5_:
  734|     32|  KeyValueFunctor ForEach(KeyValueFunctor func) {
  735|     32|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  551|     32|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 32]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 32]
  |  |  ------------------
  ------------------
  736|      0|      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
  737|      0|    }
  738|     32|    return ForEach(flat_begin(), flat_end(), std::move(func));
  739|     32|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIPNS2_8KeyValueEZNS2_D1EvE3$_0EET0_T_S8_S7_:
  727|     32|                                 KeyValueFunctor func) {
  728|     32|    for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
  ------------------
  |  Branch (728:31): [True: 0, False: 32]
  ------------------
  729|     32|    return std::move(func);
  730|     32|  }

_ZN6google8protobuf8internal11TcFieldDataC2ENS2_11DefaultInitE:
   83|  5.63k|  TcFieldData(DefaultInit) {}  // NOLINT(google-explicit-constructor)
_ZNK6google8protobuf8internal11TcFieldData10hasbit_idxEv:
  104|  2.40k|  uint8_t hasbit_idx() const { return static_cast<uint8_t>(data >> 16); }
_ZNK6google8protobuf8internal11TcFieldData7aux_idxEv:
  105|  1.94k|  uint8_t aux_idx() const { return static_cast<uint8_t>(data >> 24); }
_ZNK6google8protobuf8internal11TcFieldData6offsetEv:
  106|  2.60k|  uint16_t offset() const { return static_cast<uint16_t>(data >> 48); }
_ZNK6google8protobuf8internal11TcFieldData3tagEv:
  141|     14|  uint32_t tag() const { return static_cast<uint32_t>(data); }
_ZNK6google8protobuf8internal11TcFieldData12entry_offsetEv:
  142|     14|  uint32_t entry_offset() const { return static_cast<uint32_t>(data >> 32); }
_ZNK6google8protobuf8internal16TcParseTableBase14FastFieldEntry6targetEv:
  359|  2.61k|    TailCallParseFunc target() const {
  360|  2.61k|      return target_atomic.load(std::memory_order_relaxed);
  361|  2.61k|    }
_ZNK6google8protobuf8internal16TcParseTableBase10fast_entryEm:
  367|  2.61k|  const FastFieldEntry* fast_entry(size_t idx) const {
  368|  2.61k|    return reinterpret_cast<const FastFieldEntry*>(this + 1) + idx;
  369|  2.61k|  }
_ZNK6google8protobuf8internal16TcParseTableBase18field_lookup_beginEv:
  375|     12|  const uint16_t* field_lookup_begin() const {
  376|     12|    return reinterpret_cast<const uint16_t*>(reinterpret_cast<uintptr_t>(this) +
  377|     12|                                             lookup_table_offset);
  378|     12|  }
_ZNK6google8protobuf8internal16TcParseTableBase19field_entries_beginEv:
  395|     14|  const FieldEntry* field_entries_begin() const {
  396|     14|    return reinterpret_cast<const FieldEntry*>(
  397|     14|        reinterpret_cast<uintptr_t>(this) + field_entries_offset);
  398|     14|  }
_ZNK6google8protobuf8internal16TcParseTableBase9field_auxEj:
  440|    230|  const FieldAux* field_aux(uint32_t idx) const {
  441|    230|    return reinterpret_cast<const FieldAux*>(reinterpret_cast<uintptr_t>(this) +
  442|    230|                                             aux_offset) +
  443|    230|           idx;
  444|    230|  }
_ZNK6google8protobuf8internal16TcParseTableBase9field_auxEPKNS2_10FieldEntryE:
  450|      2|  const FieldAux* field_aux(const FieldEntry* entry) const {
  451|      2|    return field_aux(entry->aux_idx);
  452|      2|  }
_ZNK6google8protobuf8internal11TcFieldData9coded_tagIhEET_v:
  101|  2.55k|  TagType coded_tag() const {
  102|  2.55k|    return static_cast<TagType>(data);
  103|  2.55k|  }
_ZNK6google8protobuf8internal11TcFieldData9coded_tagItEET_v:
  101|     60|  TagType coded_tag() const {
  102|     60|    return static_cast<TagType>(data);
  103|     60|  }

_ZN6google8protobuf8internal8TcParser11SyncHasbitsEPNS0_11MessageLiteEmPKNS1_16TcParseTableBaseE:
  690|  1.51k|      MessageLite* msg, uint64_t hasbits, const TcParseTableBase* table) {
  691|  1.51k|    const uint32_t has_bits_offset = table->has_bits_offset;
  692|  1.51k|    if (has_bits_offset) {
  ------------------
  |  Branch (692:9): [True: 1.51k, False: 0]
  ------------------
  693|       |      // Only the first 32 has-bits are updated. Nothing above those is stored,
  694|       |      // but e.g. messages without has-bits update the upper bits.
  695|  1.51k|      RefAt<uint32_t>(msg, has_bits_offset) |= static_cast<uint32_t>(hasbits);
  696|  1.51k|    }
  697|  1.51k|  }
_ZN6google8protobuf8internal8TcParser11TagDispatchEPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  886|  2.61k|    PROTOBUF_TC_PARAM_NO_DATA_DECL) {
  887|  2.61k|  const auto coded_tag = UnalignedLoad<uint16_t>(ptr);
  888|  2.61k|  const size_t idx = coded_tag & table->fast_idx_mask;
  889|  2.61k|  PROTOBUF_ASSUME((idx & 7) == 0);
  ------------------
  |  | 1101|  2.61k|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  890|  2.61k|  auto* fast_entry = table->fast_entry(idx >> 3);
  891|  2.61k|  TcFieldData data = fast_entry->bits;
  892|  2.61k|  data.data ^= coded_tag;
  893|  2.61k|  PROTOBUF_MUSTTAIL return fast_entry->target()(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  347|  2.61k|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return fast_entry->target()(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|  2.61k|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  894|  2.61k|}
_ZN6google8protobuf8internal8TcParser13ToTagDispatchEPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  902|  1.50k|    PROTOBUF_TC_PARAM_NO_DATA_DECL) {
  903|  1.50k|  constexpr bool always_return = !PROTOBUF_TAILCALL;
  ------------------
  |  |  348|  1.50k|#define PROTOBUF_TAILCALL true
  ------------------
  904|  1.50k|  if (always_return || !ctx->DataAvailable(ptr)) {
  ------------------
  |  Branch (904:7): [Folded - Ignored]
  |  Branch (904:24): [True: 406, False: 1.10k]
  ------------------
  905|    406|    PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|    406|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|    406|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  906|    406|  }
  907|  1.50k|  PROTOBUF_MUSTTAIL return TagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|  1.10k|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return TagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|  1.10k|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  908|  1.50k|}
_ZN6google8protobuf8internal8TcParser11ToParseLoopEPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  911|  1.48k|    PROTOBUF_TC_PARAM_NO_DATA_DECL) {
  912|  1.48k|  (void)ctx;
  913|  1.48k|  SyncHasbits(msg, hasbits, table);
  914|  1.48k|  return ptr;
  915|  1.48k|}
_ZN6google8protobuf8internal8TcParser5RefAtIjEERT_Pvm:
  580|  2.14k|  static inline T& RefAt(void* x, size_t offset) {
  581|  2.14k|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  582|       |#ifndef NDEBUG
  583|       |    if (PROTOBUF_PREDICT_FALSE(
  584|       |            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
  585|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  586|       |                reinterpret_cast<uintptr_t>(target));
  587|       |      // Explicit abort to let compilers know this code-path does not return
  588|       |      abort();
  589|       |    }
  590|       |#endif
  591|  2.14k|    return *target;
  592|  2.14k|  }
_ZN6google8protobuf8internal8TcParser5RefAtIbEERT_Pvm:
  580|     36|  static inline T& RefAt(void* x, size_t offset) {
  581|     36|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  582|       |#ifndef NDEBUG
  583|       |    if (PROTOBUF_PREDICT_FALSE(
  584|       |            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
  585|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  586|       |                reinterpret_cast<uintptr_t>(target));
  587|       |      // Explicit abort to let compilers know this code-path does not return
  588|       |      abort();
  589|       |    }
  590|       |#endif
  591|     36|    return *target;
  592|     36|  }
_ZN6google8protobuf8internal8TcParser5RefAtIiEERT_Pvm:
  580|    774|  static inline T& RefAt(void* x, size_t offset) {
  581|    774|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  582|       |#ifndef NDEBUG
  583|       |    if (PROTOBUF_PREDICT_FALSE(
  584|       |            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
  585|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  586|       |                reinterpret_cast<uintptr_t>(target));
  587|       |      // Explicit abort to let compilers know this code-path does not return
  588|       |      abort();
  589|       |    }
  590|       |#endif
  591|    774|    return *target;
  592|    774|  }
_ZN6google8protobuf8internal8TcParser5RefAtINS1_14ArenaStringPtrEEERT_Pvm:
  580|    954|  static inline T& RefAt(void* x, size_t offset) {
  581|    954|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  582|       |#ifndef NDEBUG
  583|       |    if (PROTOBUF_PREDICT_FALSE(
  584|       |            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
  585|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  586|       |                reinterpret_cast<uintptr_t>(target));
  587|       |      // Explicit abort to let compilers know this code-path does not return
  588|       |      abort();
  589|       |    }
  590|       |#endif
  591|    954|    return *target;
  592|    954|  }
_ZN6google8protobuf8internal8TcParser5RefAtIPNS0_11MessageLiteEEERT_Pvm:
  580|     32|  static inline T& RefAt(void* x, size_t offset) {
  581|     32|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  582|       |#ifndef NDEBUG
  583|       |    if (PROTOBUF_PREDICT_FALSE(
  584|       |            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
  585|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  586|       |                reinterpret_cast<uintptr_t>(target));
  587|       |      // Explicit abort to let compilers know this code-path does not return
  588|       |      abort();
  589|       |    }
  590|       |#endif
  591|     32|    return *target;
  592|     32|  }
_ZN6google8protobuf8internal8TcParser5RefAtINS1_16TcParseTableBase10FieldEntryEEERKT_PKvm:
  595|     14|  static inline const T& RefAt(const void* x, size_t offset) {
  596|     14|    const T* target =
  597|     14|        reinterpret_cast<const T*>(static_cast<const char*>(x) + offset);
  598|       |#ifndef NDEBUG
  599|       |    if (PROTOBUF_PREDICT_FALSE(
  600|       |            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
  601|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  602|       |                reinterpret_cast<uintptr_t>(target));
  603|       |      // Explicit abort to let compilers know this code-path does not return
  604|       |      abort();
  605|       |    }
  606|       |#endif
  607|     14|    return *target;
  608|     14|  }
_ZN6google8protobuf8internal8TcParser5RefAtINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEEERT_Pvm:
  580|      2|  static inline T& RefAt(void* x, size_t offset) {
  581|      2|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  582|       |#ifndef NDEBUG
  583|       |    if (PROTOBUF_PREDICT_FALSE(
  584|       |            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
  585|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  586|       |                reinterpret_cast<uintptr_t>(target));
  587|       |      // Explicit abort to let compilers know this code-path does not return
  588|       |      abort();
  589|       |    }
  590|       |#endif
  591|      2|    return *target;
  592|      2|  }
_ZN6google8protobuf8internal8TcParser5RefAtINS1_20RepeatedPtrFieldBaseEEERT_Pvm:
  580|    196|  static inline T& RefAt(void* x, size_t offset) {
  581|    196|    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
  582|       |#ifndef NDEBUG
  583|       |    if (PROTOBUF_PREDICT_FALSE(
  584|       |            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
  585|       |      AlignFail(std::integral_constant<size_t, alignof(T)>(),
  586|       |                reinterpret_cast<uintptr_t>(target));
  587|       |      // Explicit abort to let compilers know this code-path does not return
  588|       |      abort();
  589|       |    }
  590|       |#endif
  591|    196|    return *target;
  592|    196|  }

_ZN6google8protobuf8internal10CachedSizeC2Ev:
  210|    746|  constexpr CachedSize() noexcept : atom_(Scalar{}) {}
_ZN6google8protobuf8internal20InitProtobufDefaultsEv:
   87|     12|PROTOBUF_EXPORT inline void InitProtobufDefaults() {
   88|     12|  if (PROTOBUF_PREDICT_FALSE(
  ------------------
  |  |  551|     12|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 12]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 12]
  |  |  ------------------
  ------------------
   89|     12|          !init_protobuf_defaults_state.load(std::memory_order_acquire))) {
   90|      0|    InitProtobufDefaultsSlow();
   91|      0|  }
   92|     12|}
_ZN6google8protobuf8internal23OnShutdownDestroyStringEPKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  254|      2|inline void OnShutdownDestroyString(const std::string* ptr) {
  255|      2|  OnShutdownRun(DestroyString, ptr);
  256|      2|}
_ZN6google8protobuf8internal17AllAreInitializedINS0_15DescriptorProtoEEEbRKNS0_16RepeatedPtrFieldIT_EE:
  119|    108|bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
  120|    204|  for (int i = t.size(); --i >= 0;) {
  ------------------
  |  Branch (120:26): [True: 96, False: 108]
  ------------------
  121|     96|    if (!t.Get(i).IsInitialized()) return false;
  ------------------
  |  Branch (121:9): [True: 0, False: 96]
  ------------------
  122|     96|  }
  123|    108|  return true;
  124|    108|}
_ZN6google8protobuf8internal17AllAreInitializedINS0_19EnumDescriptorProtoEEEbRKNS0_16RepeatedPtrFieldIT_EE:
  119|    108|bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
  120|    136|  for (int i = t.size(); --i >= 0;) {
  ------------------
  |  Branch (120:26): [True: 28, False: 108]
  ------------------
  121|     28|    if (!t.Get(i).IsInitialized()) return false;
  ------------------
  |  Branch (121:9): [True: 0, False: 28]
  ------------------
  122|     28|  }
  123|    108|  return true;
  124|    108|}
_ZN6google8protobuf8internal17AllAreInitializedINS0_22ServiceDescriptorProtoEEEbRKNS0_16RepeatedPtrFieldIT_EE:
  119|     12|bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
  120|     12|  for (int i = t.size(); --i >= 0;) {
  ------------------
  |  Branch (120:26): [True: 0, False: 12]
  ------------------
  121|      0|    if (!t.Get(i).IsInitialized()) return false;
  ------------------
  |  Branch (121:9): [True: 0, False: 0]
  ------------------
  122|      0|  }
  123|     12|  return true;
  124|     12|}
_ZN6google8protobuf8internal17AllAreInitializedINS0_20FieldDescriptorProtoEEEbRKNS0_16RepeatedPtrFieldIT_EE:
  119|    204|bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
  120|    590|  for (int i = t.size(); --i >= 0;) {
  ------------------
  |  Branch (120:26): [True: 386, False: 204]
  ------------------
  121|    386|    if (!t.Get(i).IsInitialized()) return false;
  ------------------
  |  Branch (121:9): [True: 0, False: 386]
  ------------------
  122|    386|  }
  123|    204|  return true;
  124|    204|}
_ZN6google8protobuf8internal17AllAreInitializedINS0_30DescriptorProto_ExtensionRangeEEEbRKNS0_16RepeatedPtrFieldIT_EE:
  119|     96|bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
  120|    114|  for (int i = t.size(); --i >= 0;) {
  ------------------
  |  Branch (120:26): [True: 18, False: 96]
  ------------------
  121|     18|    if (!t.Get(i).IsInitialized()) return false;
  ------------------
  |  Branch (121:9): [True: 0, False: 18]
  ------------------
  122|     18|  }
  123|     96|  return true;
  124|     96|}
_ZN6google8protobuf8internal17AllAreInitializedINS0_20OneofDescriptorProtoEEEbRKNS0_16RepeatedPtrFieldIT_EE:
  119|     96|bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
  120|     98|  for (int i = t.size(); --i >= 0;) {
  ------------------
  |  Branch (120:26): [True: 2, False: 96]
  ------------------
  121|      2|    if (!t.Get(i).IsInitialized()) return false;
  ------------------
  |  Branch (121:9): [True: 0, False: 2]
  ------------------
  122|      2|  }
  123|     96|  return true;
  124|     96|}
_ZN6google8protobuf8internal17AllAreInitializedINS0_19UninterpretedOptionEEEbRKNS0_16RepeatedPtrFieldIT_EE:
  119|     32|bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
  120|     32|  for (int i = t.size(); --i >= 0;) {
  ------------------
  |  Branch (120:26): [True: 0, False: 32]
  ------------------
  121|      0|    if (!t.Get(i).IsInitialized()) return false;
  ------------------
  |  Branch (121:9): [True: 0, False: 0]
  ------------------
  122|      0|  }
  123|     32|  return true;
  124|     32|}
_ZN6google8protobuf8internal17AllAreInitializedINS0_24EnumValueDescriptorProtoEEEbRKNS0_16RepeatedPtrFieldIT_EE:
  119|     28|bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
  120|    184|  for (int i = t.size(); --i >= 0;) {
  ------------------
  |  Branch (120:26): [True: 156, False: 28]
  ------------------
  121|    156|    if (!t.Get(i).IsInitialized()) return false;
  ------------------
  |  Branch (121:9): [True: 0, False: 156]
  ------------------
  122|    156|  }
  123|     28|  return true;
  124|     28|}

_ZNK6google8protobuf8internal7HasBitsILm1EEixEi:
   61|    698|  PROTOBUF_NDEBUG_INLINE const uint32_t& operator[](int index) const {
   62|    698|    return has_bits_[index];
   63|    698|  }
_ZN6google8protobuf8internal7HasBitsILm1EEixEi:
   57|     12|  PROTOBUF_NDEBUG_INLINE uint32_t& operator[](int index) {
   58|     12|    return has_bits_[index];
   59|     12|  }
_ZN6google8protobuf8internal7HasBitsILm1EEC2Ev:
   51|    746|  PROTOBUF_NDEBUG_INLINE constexpr HasBits() : has_bits_{} {}
_ZN6google8protobuf8internal7HasBitsILm1EE5ClearEv:
   53|     12|  PROTOBUF_NDEBUG_INLINE void Clear() {
   54|     12|    memset(has_bits_, 0, sizeof(has_bits_));
   55|     12|  }

_ZN6google8protobuf11MessageLiteC2EPNS0_5ArenaE:
  469|    746|  inline explicit MessageLite(Arena* arena) : _internal_metadata_(arena) {}
_ZNK6google8protobuf11MessageLite21GetArenaForAllocationEv:
  480|    986|  Arena* GetArenaForAllocation() const { return _internal_metadata_.arena(); }
_ZNK6google8protobuf11MessageLite23IsInitializedWithErrorsEv:
  505|     12|  bool IsInitializedWithErrors() const {
  506|     12|    if (IsInitialized()) return true;
  ------------------
  |  Branch (506:9): [True: 12, False: 0]
  ------------------
  507|      0|    LogInitializationErrorMessage();
  508|      0|    return false;
  509|     12|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_30DescriptorProto_ExtensionRangeEEEPT_PNS0_5ArenaE:
  465|     18|  static T* CreateMaybeMessage(Arena* arena) {
  466|     18|    return Arena::CreateMaybeMessage<T>(arena);
  467|     18|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_29DescriptorProto_ReservedRangeEEEPT_PNS0_5ArenaE:
  465|     16|  static T* CreateMaybeMessage(Arena* arena) {
  466|     16|    return Arena::CreateMaybeMessage<T>(arena);
  467|     16|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_15DescriptorProtoEEEPT_PNS0_5ArenaE:
  465|     96|  static T* CreateMaybeMessage(Arena* arena) {
  466|     96|    return Arena::CreateMaybeMessage<T>(arena);
  467|     96|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_20FieldDescriptorProtoEEEPT_PNS0_5ArenaE:
  465|    386|  static T* CreateMaybeMessage(Arena* arena) {
  466|    386|    return Arena::CreateMaybeMessage<T>(arena);
  467|    386|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_20OneofDescriptorProtoEEEPT_PNS0_5ArenaE:
  465|      2|  static T* CreateMaybeMessage(Arena* arena) {
  466|      2|    return Arena::CreateMaybeMessage<T>(arena);
  467|      2|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_19EnumDescriptorProtoEEEPT_PNS0_5ArenaE:
  465|     28|  static T* CreateMaybeMessage(Arena* arena) {
  466|     28|    return Arena::CreateMaybeMessage<T>(arena);
  467|     28|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_24EnumValueDescriptorProtoEEEPT_PNS0_5ArenaE:
  465|    156|  static T* CreateMaybeMessage(Arena* arena) {
  466|    156|    return Arena::CreateMaybeMessage<T>(arena);
  467|    156|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_11FileOptionsEEEPT_PNS0_5ArenaE:
  465|     12|  static T* CreateMaybeMessage(Arena* arena) {
  466|     12|    return Arena::CreateMaybeMessage<T>(arena);
  467|     12|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_14MessageOptionsEEEPT_PNS0_5ArenaE:
  465|      2|  static T* CreateMaybeMessage(Arena* arena) {
  466|      2|    return Arena::CreateMaybeMessage<T>(arena);
  467|      2|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_12FieldOptionsEEEPT_PNS0_5ArenaE:
  465|     18|  static T* CreateMaybeMessage(Arena* arena) {
  466|     18|    return Arena::CreateMaybeMessage<T>(arena);
  467|     18|  }
_ZN6google8protobuf11MessageLiteD2Ev:
  175|    746|  virtual ~MessageLite() = default;
_ZN6google8protobuf8internal16OnShutdownDeleteINS0_25EncodedDescriptorDatabaseEEEPT_S5_:
  614|      2|T* OnShutdownDelete(T* p) {
  615|      2|  OnShutdownRun([](const void* pp) { delete static_cast<const T*>(pp); }, p);
  616|      2|  return p;
  617|      2|}
message.cc:_ZN6google8protobuf8internal16OnShutdownDeleteINS0_12_GLOBAL__N_123GeneratedMessageFactoryEEEPT_S6_:
  614|      2|T* OnShutdownDelete(T* p) {
  615|      2|  OnShutdownRun([](const void* pp) { delete static_cast<const T*>(pp); }, p);
  616|      2|  return p;
  617|      2|}
_ZN6google8protobuf11MessageLite9ParseFromILNS1_10ParseFlagsE1EN4absl12lts_2023012511string_viewEEEbRKT0_:
  580|     12|bool MessageLite::ParseFrom(const T& input) {
  581|     12|  if (flags & kParse) Clear();
  ------------------
  |  Branch (581:7): [Folded - Ignored]
  ------------------
  582|     12|  constexpr bool alias = (flags & kMergeWithAliasing) != 0;
  583|     12|  return internal::MergeFromImpl<alias>(input, this, flags);
  584|     12|}

_ZN6google8protobuf8internal16InternalMetadataC2EPNS0_5ArenaE:
   70|    746|  explicit InternalMetadata(Arena* arena) {
   71|    746|    ptr_ = reinterpret_cast<intptr_t>(arena);
   72|    746|  }
_ZNK6google8protobuf8internal16InternalMetadata5arenaEv:
   89|    986|  PROTOBUF_NDEBUG_INLINE Arena* arena() const {
   90|    986|    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
  ------------------
  |  |  551|    986|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 986]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 986]
  |  |  ------------------
  ------------------
   91|      0|      return PtrValue<ContainerBase>()->arena;
   92|    986|    } else {
   93|    986|      return PtrValue<Arena>();
   94|    986|    }
   95|    986|  }
_ZNK6google8protobuf8internal16InternalMetadata19have_unknown_fieldsEv:
   97|  1.74k|  PROTOBUF_NDEBUG_INLINE bool have_unknown_fields() const {
   98|  1.74k|    return HasUnknownFieldsTag();
   99|  1.74k|  }
_ZNK6google8protobuf8internal16InternalMetadata19HasUnknownFieldsTagEv:
  164|  1.74k|  PROTOBUF_ALWAYS_INLINE bool HasUnknownFieldsTag() const {
  165|  1.74k|    return ptr_ & kUnknownFieldsTagMask;
  166|  1.74k|  }
_ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS0_5ArenaEEEPT_v:
  169|    986|  U* PtrValue() const {
  170|    986|    return reinterpret_cast<U*>(ptr_ & kPtrValueMask);
  171|    986|  }
_ZN6google8protobuf8internal16InternalMetadata6DeleteINS0_15UnknownFieldSetEEEvv:
   82|    746|  void Delete() {
   83|       |    // Note that Delete<> should be called not more than once.
   84|    746|    if (have_unknown_fields()) {
  ------------------
  |  Branch (84:9): [True: 0, False: 746]
  ------------------
   85|      0|      DeleteOutOfLineHelper<T>();
   86|      0|    }
   87|    746|  }
_ZN6google8protobuf8internal16InternalMetadata5ClearINS0_15UnknownFieldSetEEEvv:
  149|     12|  PROTOBUF_NDEBUG_INLINE void Clear() {
  150|     12|    if (have_unknown_fields()) {
  ------------------
  |  Branch (150:9): [True: 0, False: 12]
  ------------------
  151|      0|      DoClear<T>();
  152|      0|    }
  153|     12|  }

_ZN6google8protobuf8internal18EpsCopyInputStreamC2Eb:
  124|     12|      : aliasing_(enable_aliasing ? kOnPatch : kNoAliasing) {}
_ZN6google8protobuf8internal18EpsCopyInputStream10LimitTokenC2Ev:
  143|    734|    LimitToken() { PROTOBUF_POISON_MEMORY_REGION(&token_, sizeof(token_)); }
_ZN6google8protobuf8internal18EpsCopyInputStream10LimitTokenC2Ei:
  145|    734|    explicit LimitToken(int token) : token_(token) {
  146|    734|      PROTOBUF_UNPOISON_MEMORY_REGION(&token_, sizeof(token_));
  147|    734|    }
_ZN6google8protobuf8internal18EpsCopyInputStream10LimitTokenC2EOS3_:
  152|    734|    LimitToken(LimitToken&& other) { *this = std::move(other); }
_ZN6google8protobuf8internal18EpsCopyInputStream10LimitTokenaSEOS3_:
  154|  1.46k|    LimitToken& operator=(LimitToken&& other) {
  155|  1.46k|      PROTOBUF_UNPOISON_MEMORY_REGION(&token_, sizeof(token_));
  156|  1.46k|      token_ = other.token_;
  157|  1.46k|      PROTOBUF_POISON_MEMORY_REGION(&other.token_, sizeof(token_));
  158|  1.46k|      return *this;
  159|  1.46k|    }
_ZNO6google8protobuf8internal18EpsCopyInputStream10LimitToken5tokenEv:
  163|    734|    int token() && {
  164|    734|      int t = token_;
  165|    734|      PROTOBUF_POISON_MEMORY_REGION(&token_, sizeof(token_));
  166|    734|      return t;
  167|    734|    }
_ZN6google8protobuf8internal18EpsCopyInputStream9PushLimitEPKci:
  174|    734|  PROTOBUF_NODISCARD LimitToken PushLimit(const char* ptr, int limit) {
  175|    734|    ABSL_DCHECK(limit >= 0 && limit <= INT_MAX - kSlopBytes);
  ------------------
  |  |   43|    734|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|    734|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|    734|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|    734|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|    734|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|    734|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  176|       |    // This add is safe due to the invariant above, because
  177|       |    // ptr - buffer_end_ <= kSlopBytes.
  178|    734|    limit += static_cast<int>(ptr - buffer_end_);
  179|    734|    limit_end_ = buffer_end_ + (std::min)(0, limit);
  180|    734|    auto old_limit = limit_;
  181|    734|    limit_ = limit;
  182|    734|    return LimitToken(old_limit - limit);
  183|    734|  }
_ZN6google8protobuf8internal18EpsCopyInputStream8PopLimitENS2_10LimitTokenE:
  185|    734|  PROTOBUF_NODISCARD bool PopLimit(LimitToken delta) {
  186|       |    // We must update the limit first before the early return. Otherwise, we can
  187|       |    // end up with an invalid limit and it can lead to integer overflows.
  188|    734|    limit_ = limit_ + std::move(delta).token();
  189|    734|    if (PROTOBUF_PREDICT_FALSE(!EndedAtLimit())) return false;
  ------------------
  |  |  551|    734|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 734]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 734]
  |  |  ------------------
  ------------------
  190|       |    // TODO(gerbens) We could remove this line and hoist the code to
  191|       |    // DoneFallback. Study the perf/bin-size effects.
  192|    734|    limit_end_ = buffer_end_ + (std::min)(0, limit_);
  193|    734|    return true;
  194|    734|  }
_ZN6google8protobuf8internal18EpsCopyInputStream10ReadStringEPKciPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  203|    958|                                            std::string* s) {
  204|    958|    if (size <= buffer_end_ + kSlopBytes - ptr) {
  ------------------
  |  Branch (204:9): [True: 958, False: 0]
  ------------------
  205|       |      // Fundamentally we just want to do assign to the string.
  206|       |      // However micro-benchmarks regress on string reading cases. So we copy
  207|       |      // the same logic from the old CodedInputStream ReadString. Note: as of
  208|       |      // Apr 2021, this is still a significant win over `assign()`.
  209|    958|      absl::strings_internal::STLStringResizeUninitialized(s, size);
  210|    958|      char* z = &(*s)[0];
  211|    958|      memcpy(z, ptr, size);
  212|    958|      return ptr + size;
  213|    958|    }
  214|      0|    return ReadStringFallback(ptr, size, s);
  215|    958|  }
_ZNK6google8protobuf8internal18EpsCopyInputStream7LastTagEv:
  256|  1.51k|  uint32_t LastTag() const { return last_tag_minus_1_ + 1; }
_ZNK6google8protobuf8internal18EpsCopyInputStream12EndedAtLimitEv:
  262|    746|  bool EndedAtLimit() const { return last_tag_minus_1_ == 0; }
_ZN6google8protobuf8internal18EpsCopyInputStream13DataAvailableEPKc:
  280|  2.21k|  bool DataAvailable(const char* ptr) { return ptr < limit_end_; }
_ZN6google8protobuf8internal18EpsCopyInputStream13DoneWithCheckEPPKci:
  286|  2.26k|  bool DoneWithCheck(const char** ptr, int d) {
  287|  2.26k|    ABSL_DCHECK(*ptr);
  ------------------
  |  |   43|  2.26k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  2.26k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  2.26k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  2.26k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  2.26k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  2.26k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  288|  2.26k|    if (PROTOBUF_PREDICT_TRUE(*ptr < limit_end_)) return false;
  ------------------
  |  |  550|  2.26k|# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (550:35): [True: 1.50k, False: 756]
  |  |  |  Branch (550:53): [Folded - Ignored]
  |  |  |  Branch (550:62): [True: 1.50k, False: 756]
  |  |  ------------------
  ------------------
  289|    756|    int overrun = static_cast<int>(*ptr - buffer_end_);
  290|    756|    ABSL_DCHECK_LE(overrun, kSlopBytes);  // Guaranteed by parse loop.
  ------------------
  |  |   74|    756|  ABSL_DCHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   90|    756|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|    756|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    756|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  291|    756|    if (overrun ==
  ------------------
  |  Branch (291:9): [True: 746, False: 10]
  ------------------
  292|    756|        limit_) {  //  No need to flip buffers if we ended on a limit.
  293|       |      // If we actually overrun the buffer and next_chunk_ is null. It means
  294|       |      // the stream ended and we passed the stream end.
  295|    746|      if (overrun > 0 && next_chunk_ == nullptr) *ptr = nullptr;
  ------------------
  |  Branch (295:11): [True: 14, False: 732]
  |  Branch (295:26): [True: 0, False: 14]
  ------------------
  296|    746|      return true;
  297|    746|    }
  298|     10|    auto res = DoneFallback(overrun, d);
  299|     10|    *ptr = res.first;
  300|     10|    return res.second;
  301|    756|  }
_ZN6google8protobuf8internal18EpsCopyInputStream8InitFromEN4absl12lts_2023012511string_viewE:
  303|     12|  const char* InitFrom(absl::string_view flat) {
  304|     12|    overall_limit_ = 0;
  305|     12|    if (flat.size() > kSlopBytes) {
  ------------------
  |  Branch (305:9): [True: 12, False: 0]
  ------------------
  306|     12|      limit_ = kSlopBytes;
  307|     12|      limit_end_ = buffer_end_ = flat.data() + flat.size() - kSlopBytes;
  308|     12|      next_chunk_ = patch_buffer_;
  309|     12|      if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
  ------------------
  |  Branch (309:11): [True: 0, False: 12]
  ------------------
  310|     12|      return flat.data();
  311|     12|    } else {
  312|      0|      if (!flat.empty()) {
  ------------------
  |  Branch (312:11): [True: 0, False: 0]
  ------------------
  313|      0|        std::memcpy(patch_buffer_, flat.data(), flat.size());
  314|      0|      }
  315|      0|      limit_ = 0;
  316|      0|      limit_end_ = buffer_end_ = patch_buffer_ + flat.size();
  317|      0|      next_chunk_ = nullptr;
  318|      0|      if (aliasing_ == kOnPatch) {
  ------------------
  |  Branch (318:11): [True: 0, False: 0]
  ------------------
  319|      0|        aliasing_ = reinterpret_cast<std::uintptr_t>(flat.data()) -
  320|      0|                    reinterpret_cast<std::uintptr_t>(patch_buffer_);
  321|      0|      }
  322|      0|      return patch_buffer_;
  323|      0|    }
  324|     12|  }
_ZN6google8protobuf8internal12ParseContext4DoneEPPKc:
  487|  2.26k|  bool Done(const char** ptr) { return DoneWithCheck(ptr, group_depth_); }
_ZN6google8protobuf8internal12EndianHelperILi1EE4LoadEPKv:
  618|  1.74k|  static uint8_t Load(const void* p) { return *static_cast<const uint8_t*>(p); }
_ZN6google8protobuf8internal12EndianHelperILi2EE4LoadEPKv:
  623|  2.63k|  static uint16_t Load(const void* p) {
  624|  2.63k|    uint16_t tmp;
  625|  2.63k|    std::memcpy(&tmp, p, 2);
  626|  2.63k|    return little_endian::ToHost(tmp);
  627|  2.63k|  }
_ZN6google8protobuf8internal10RotateLeftImEET_S3_i:
  969|     14|    T x, int s) noexcept {
  970|     14|  return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) |
  971|     14|         static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
  972|     14|}
_ZN6google8protobuf8internal26RotRight7AndReplaceLowByteEmRKc:
  975|     14|RotRight7AndReplaceLowByte(uint64_t res, const char& byte) {
  976|       |  // TODO(b/239808098): remove the inline assembly
  977|     14|#if defined(__x86_64__) && defined(__GNUC__)
  978|       |  // This will only use one register for `res`.
  979|       |  // `byte` comes as a reference to allow the compiler to generate code like:
  980|       |  //
  981|       |  //   rorq    $7, %rcx
  982|       |  //   movb    1(%rax), %cl
  983|       |  //
  984|       |  // which avoids loading the incoming bytes into a separate register first.
  985|     14|  asm("ror $7,%0\n\t"
  986|     14|      "movb %1,%b0"
  987|     14|      : "+r"(res)
  988|     14|      : "m"(byte));
  989|       |#else
  990|       |  res = RotateLeft(res, -7);
  991|       |  res = res & ~0xFF;
  992|       |  res |= 0xFF & byte;
  993|       |#endif
  994|     14|  return res;
  995|     14|};
_ZN6google8protobuf8internal14ReadTagInlinedEPKcPj:
  998|     14|                                                         uint32_t* out) {
  999|     14|  uint64_t res = 0xFF & ptr[0];
 1000|     14|  if (PROTOBUF_PREDICT_FALSE(res >= 128)) {
  ------------------
  |  |  551|     14|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 14, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 14, False: 0]
  |  |  ------------------
  ------------------
 1001|     14|    res = RotRight7AndReplaceLowByte(res, ptr[1]);
 1002|     14|    if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
  ------------------
  |  |  551|     14|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 14]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 14]
  |  |  ------------------
  ------------------
 1003|      0|      res = RotRight7AndReplaceLowByte(res, ptr[2]);
 1004|      0|      if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
  ------------------
  |  |  551|      0|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1005|      0|        res = RotRight7AndReplaceLowByte(res, ptr[3]);
 1006|      0|        if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
  ------------------
  |  |  551|      0|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1007|       |          // Note: this wouldn't work if res were 32-bit,
 1008|       |          // because then replacing the low byte would overwrite
 1009|       |          // the bottom 4 bits of the result.
 1010|      0|          res = RotRight7AndReplaceLowByte(res, ptr[4]);
 1011|      0|          if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
  ------------------
  |  |  551|      0|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1012|       |            // The proto format does not permit longer than 5-byte encodings for
 1013|       |            // tags.
 1014|      0|            *out = 0;
 1015|      0|            return nullptr;
 1016|      0|          }
 1017|      0|          *out = static_cast<uint32_t>(RotateLeft(res, 28));
 1018|      0|#if defined(__GNUC__)
 1019|       |          // Note: this asm statement prevents the compiler from
 1020|       |          // trying to share the "return ptr + constant" among all
 1021|       |          // branches.
 1022|      0|          asm("" : "+r"(ptr));
 1023|      0|#endif
 1024|      0|          return ptr + 5;
 1025|      0|        }
 1026|      0|        *out = static_cast<uint32_t>(RotateLeft(res, 21));
 1027|      0|        return ptr + 4;
 1028|      0|      }
 1029|      0|      *out = static_cast<uint32_t>(RotateLeft(res, 14));
 1030|      0|      return ptr + 3;
 1031|      0|    }
 1032|     14|    *out = static_cast<uint32_t>(RotateLeft(res, 7));
 1033|     14|    return ptr + 2;
 1034|     14|  }
 1035|      0|  *out = static_cast<uint32_t>(res);
 1036|      0|  return ptr + 1;
 1037|     14|}
_ZN6google8protobuf8internal8ReadSizeEPPKc:
 1089|  1.69k|inline uint32_t ReadSize(const char** pp) {
 1090|  1.69k|  auto p = *pp;
 1091|  1.69k|  uint32_t res = static_cast<uint8_t>(p[0]);
 1092|  1.69k|  if (res < 128) {
  ------------------
  |  Branch (1092:7): [True: 1.63k, False: 56]
  ------------------
 1093|  1.63k|    *pp = p + 1;
 1094|  1.63k|    return res;
 1095|  1.63k|  }
 1096|     56|  auto x = ReadSizeFallback(p, res);
 1097|     56|  *pp = x.first;
 1098|     56|  return x.second;
 1099|  1.69k|}
_ZN6google8protobuf8internal12ParseContext35ReadSizeAndPushLimitAndDepthInlinedEPKcPNS1_18EpsCopyInputStream10LimitTokenE:
 1158|    734|    const char* ptr, LimitToken* old_limit) {
 1159|    734|  int size = ReadSize(&ptr);
 1160|    734|  if (PROTOBUF_PREDICT_FALSE(!ptr) || depth_ <= 0) {
  ------------------
  |  |  551|  1.46k|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 734]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 734]
  |  |  ------------------
  ------------------
  |  Branch (1160:39): [True: 0, False: 734]
  ------------------
 1161|      0|    return nullptr;
 1162|      0|  }
 1163|    734|  *old_limit = PushLimit(ptr, size);
 1164|    734|  --depth_;
 1165|    734|  return ptr;
 1166|    734|}
_ZN6google8protobuf8internal13UnalignedLoadItEET_PKc:
  649|  2.63k|T UnalignedLoad(const char* p) {
  650|  2.63k|  auto tmp = EndianHelper<sizeof(T)>::Load(p);
  651|  2.63k|  T res;
  652|  2.63k|  memcpy(&res, &tmp, sizeof(T));
  653|  2.63k|  return res;
  654|  2.63k|}
_ZN6google8protobuf8internal12ParseContextC2IJRN4absl12lts_2023012511string_viewEEEEibPPKcDpOT_:
  479|     12|      : EpsCopyInputStream(aliasing), depth_(depth) {
  480|     12|    *start = InitFrom(std::forward<T>(args)...);
  481|     12|  }
_ZN6google8protobuf8internal13UnalignedLoadIhEET_PKc:
  649|  1.74k|T UnalignedLoad(const char* p) {
  650|  1.74k|  auto tmp = EndianHelper<sizeof(T)>::Load(p);
  651|  1.74k|  T res;
  652|  1.74k|  memcpy(&res, &tmp, sizeof(T));
  653|  1.74k|  return res;
  654|  1.74k|}
_ZN6google8protobuf8internal12ParseContext12ParseMessageINS1_8TcParserENS1_16TcParseTableBaseEEEPKcPNS0_11MessageLiteES7_PKT0_:
  525|    734|      MessageLite* msg, const char* ptr, const Table* table) {
  526|    734|    LimitToken old;
  527|    734|    ptr = ReadSizeAndPushLimitAndDepthInlined(ptr, &old);
  528|    734|    if (ptr == nullptr) return ptr;
  ------------------
  |  Branch (528:9): [True: 0, False: 734]
  ------------------
  529|    734|    auto old_depth = depth_;
  530|    734|    ptr = TcParser::ParseLoop(msg, ptr, this, table);
  531|    734|    if (ptr != nullptr) ABSL_DCHECK_EQ(old_depth, depth_);
  ------------------
  |  |   70|    734|  ABSL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   86|    734|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|    734|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    734|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (531:9): [True: 734, False: 0]
  ------------------
  532|    734|    depth_++;
  533|    734|    if (!PopLimit(std::move(old))) return nullptr;
  ------------------
  |  Branch (533:9): [True: 0, False: 734]
  ------------------
  534|    734|    return ptr;
  535|    734|  }

_ZN6google8protobuf8internal15AllocateAtLeastEm:
  102|    390|inline SizedPtr AllocateAtLeast(size_t size) {
  103|       |#if !defined(NDEBUG) && defined(ABSL_HAVE_THREAD_LOCAL) && \
  104|       |    defined(__cpp_inline_variables)
  105|       |  if (allocate_at_least_hook != nullptr) {
  106|       |    return allocate_at_least_hook(size, allocate_at_least_hook_context);
  107|       |  }
  108|       |#endif  // !NDEBUG && ABSL_HAVE_THREAD_LOCAL && __cpp_inline_variables
  109|    390|  return {::operator new(size), size};
  110|    390|}
_ZN6google8protobuf8internal11SizedDeleteEPvm:
  112|    390|inline void SizedDelete(void* p, size_t size) {
  113|       |#if defined(__cpp_sized_deallocation)
  114|       |  ::operator delete(p, size);
  115|       |#else
  116|       |  // Avoid -Wunused-parameter
  117|    390|  (void)size;
  118|    390|  ::operator delete(p);
  119|    390|#endif
  120|    390|}
_ZN6google8protobuf8internal16SizedArrayDeleteEPvm:
  121|     32|inline void SizedArrayDelete(void* p, size_t size) {
  122|       |#if defined(__cpp_sized_deallocation)
  123|       |  ::operator delete[](p, size);
  124|       |#else
  125|       |  // Avoid -Wunused-parameter
  126|     32|  (void)size;
  127|     32|  ::operator delete[](p);
  128|     32|#endif
  129|     32|}

_ZNK6google8protobuf13RepeatedFieldIiE15unsafe_elementsEv:
  466|     48|  Element* unsafe_elements() const {
  467|     48|    return static_cast<Element*>(arena_or_elements_);
  468|     48|  }
_ZN6google8protobuf13RepeatedFieldIiE19ExchangeCurrentSizeEi:
  431|     24|  inline int ExchangeCurrentSize(int new_size) {
  432|     24|    const int prev_size = current_size_;
  433|     24|    AnnotateSize(prev_size, new_size);
  434|     24|    current_size_ = new_size;
  435|     24|    return prev_size;
  436|     24|  }
_ZNK6google8protobuf13RepeatedFieldIiE12AnnotateSizeEii:
  414|     24|  void AnnotateSize(int old_size, int new_size) const {
  415|     24|    if (old_size != new_size) {
  ------------------
  |  Branch (415:9): [True: 0, False: 24]
  ------------------
  416|      0|      ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(
  417|      0|          unsafe_elements(), unsafe_elements() + total_size_,
  418|      0|          unsafe_elements() + old_size, unsafe_elements() + new_size);
  419|      0|      if (new_size < old_size) {
  ------------------
  |  Branch (419:11): [True: 0, False: 0]
  ------------------
  420|      0|        ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(
  421|      0|            unsafe_elements() + new_size,
  422|      0|            (old_size - new_size) * sizeof(Element));
  423|      0|      }
  424|      0|    }
  425|     24|  }
_ZN6google8protobuf13RepeatedFieldIiE7DestroyEPKiS4_:
  482|     24|  static void Destroy(const Element* begin, const Element* end) {
  483|     24|    if (!std::is_trivial<Element>::value) {
  ------------------
  |  Branch (483:9): [Folded - Ignored]
  ------------------
  484|      0|      std::for_each(begin, end, [&](const Element& e) { e.~Element(); });
  485|      0|    }
  486|     24|  }
_ZN6google8protobuf13RepeatedFieldIiE5ClearEv:
  799|     24|inline void RepeatedField<Element>::Clear() {
  800|     24|  Destroy(unsafe_elements(), unsafe_elements() + current_size_);
  801|     24|  ExchangeCurrentSize(0);
  802|     24|}
_ZN6google8protobuf13RepeatedFieldIiE19StaticValidityCheckEv:
  175|     84|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  176|     84|    static_assert(
  177|     84|        absl::disjunction<internal::is_supported_integral_type<Element>,
  178|     84|                          internal::is_supported_floating_point_type<Element>,
  179|     84|                          std::is_same<absl::Cord, Element>,
  180|     84|                          is_proto_enum<Element>>::value,
  181|     84|        "We only support non-string scalars in RepeatedField.");
  182|     84|  }
_ZN6google8protobuf13RepeatedFieldIiED2Ev:
  536|     42|RepeatedField<Element>::~RepeatedField() {
  537|     42|  StaticValidityCheck();
  538|       |#ifndef NDEBUG
  539|       |  // Try to trigger segfault / asan failure in non-opt builds if arena_
  540|       |  // lifetime has ended before the destructor.
  541|       |  auto arena = GetOwningArena();
  542|       |  if (arena) (void)arena->SpaceAllocated();
  543|       |#endif
  544|     42|  if (total_size_ > 0) {
  ------------------
  |  Branch (544:7): [True: 0, False: 42]
  ------------------
  545|      0|    Destroy(unsafe_elements(), unsafe_elements() + current_size_);
  546|      0|    InternalDeallocate<true>();
  547|      0|  }
  548|     42|}
_ZN6google8protobuf13RepeatedFieldIiEC2EPNS0_5ArenaE:
  512|     42|    : current_size_(0), total_size_(0), arena_or_elements_(arena) {
  513|     42|  StaticValidityCheck();
  514|     42|}
_ZN6google8protobuf8internal20CalculateReserveSizeIPvLi8EEEiii:
  947|    390|inline int CalculateReserveSize(int total_size, int new_size) {
  948|    390|  constexpr int lower_limit = RepeatedFieldLowerClampLimit<T, kRepHeaderSize>();
  949|    390|  if (new_size < lower_limit) {
  ------------------
  |  Branch (949:7): [True: 0, False: 390]
  ------------------
  950|       |    // Clamp to smallest allowed size.
  951|      0|    return lower_limit;
  952|      0|  }
  953|    390|  constexpr int kMaxSizeBeforeClamp =
  954|    390|      (std::numeric_limits<int>::max() - kRepHeaderSize) / 2;
  955|    390|  if (PROTOBUF_PREDICT_FALSE(total_size > kMaxSizeBeforeClamp)) {
  ------------------
  |  |  551|    390|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 390]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 390]
  |  |  ------------------
  ------------------
  956|      0|    return std::numeric_limits<int>::max();
  957|      0|  }
  958|       |  // We want to double the number of bytes, not the number of elements, to try
  959|       |  // to stay within power-of-two allocations.
  960|       |  // The allocation has kRepHeaderSize + sizeof(T) * capacity.
  961|    390|  int doubled_size = 2 * total_size + kRepHeaderSize / sizeof(T);
  962|    390|  return std::max(doubled_size, new_size);
  963|    390|}

_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2EPNS0_5ArenaE:
  170|    944|      : arena_(arena), current_size_(0), total_size_(0), rep_(nullptr) {}
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseD2Ev:
  175|    944|  ~RepeatedPtrFieldBase() {
  176|       |#ifndef NDEBUG
  177|       |    // Try to trigger segfault / asan failure in non-opt builds. If arena_
  178|       |    // lifetime has ended before the destructor.
  179|       |    if (arena_) (void)arena_->SpaceAllocated();
  180|       |#endif
  181|    944|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv:
  184|    924|  int size() const { return current_size_; }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase12NeedsDestroyEv:
  262|    808|  bool NeedsDestroy() const { return rep_ != nullptr && arena_ == nullptr; }
  ------------------
  |  Branch (262:38): [True: 196, False: 612]
  |  Branch (262:57): [True: 196, False: 0]
  ------------------
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8raw_dataEv:
  373|    480|  void* const* raw_data() const { return rep_ ? rep_->elements : nullptr; }
  ------------------
  |  Branch (373:42): [True: 60, False: 420]
  ------------------
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase14GetOwningArenaEv:
  645|    392|  inline Arena* GetOwningArena() const { return arena_; }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase19ExchangeCurrentSizeEi:
  669|    706|  inline int ExchangeCurrentSize(int new_size) {
  670|    706|    int prev_size = current_size_;
  671|    706|    current_size_ = new_size;
  672|    706|    return prev_size;
  673|    706|  }
_ZN6google8protobuf8internal17StringTypeHandler3NewEPNS0_5ArenaE:
  875|      4|  static PROTOBUF_NOINLINE std::string* New(Arena* arena) {
  876|      4|    return Arena::Create<std::string>(arena);
  877|      4|  }
_ZN6google8protobuf8internal17StringTypeHandler16NewFromPrototypeEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPNS0_5ArenaE:
  882|      4|                                              Arena* arena) {
  883|      4|    return New(arena);
  884|      4|  }
_ZN6google8protobuf8internal17StringTypeHandler6DeleteEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPNS0_5ArenaE:
  886|      4|  static inline void Delete(std::string* value, Arena* arena) {
  887|      4|    if (arena == nullptr) {
  ------------------
  |  Branch (887:9): [True: 4, False: 0]
  ------------------
  888|      4|      delete value;
  889|      4|    }
  890|      4|  }
_ZN6google8protobuf8internal18GenericTypeHandlerINS0_11MessageLiteEE16NewFromPrototypeEPKS3_PNS0_5ArenaE:
  834|    702|    const MessageLite* prototype, Arena* arena) {
  835|    702|  return NewFromPrototypeHelper(prototype, arena);
  836|    702|}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5ClearEv:
 1505|     12|inline void RepeatedPtrField<Element>::Clear() {
 1506|     12|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 1507|     12|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEvv:
  284|     12|  void Clear() {
  285|     12|    const int n = current_size_;
  286|     12|    ABSL_DCHECK_GE(n, 0);
  ------------------
  |  |   78|     12|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|     12|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     12|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     12|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  287|     12|    if (n > 0) {
  ------------------
  |  Branch (287:9): [True: 0, False: 12]
  ------------------
  288|      0|      ClearNonEmpty<TypeHandler>();
  289|      0|    }
  290|     12|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEPNT_4TypeEPv:
  686|      4|  static inline typename TypeHandler::Type* cast(void* element) {
  687|      4|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  688|      4|  }
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE3AddEv:
 1376|      4|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1377|      4|  return RepeatedPtrFieldBase::Add<TypeHandler>();
 1378|      4|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEPNT_4TypeEPKSF_:
  210|      4|      const typename TypeHandler::Type* prototype = nullptr) {
  211|      4|    if (rep_ != nullptr && current_size_ < rep_->allocated_size) {
  ------------------
  |  Branch (211:9): [True: 2, False: 2]
  |  Branch (211:28): [True: 0, False: 2]
  ------------------
  212|      0|      return cast<TypeHandler>(
  213|      0|          rep_->elements[ExchangeCurrentSize(current_size_ + 1)]);
  214|      0|    }
  215|      4|    typename TypeHandler::Type* result =
  216|      4|        TypeHandler::NewFromPrototype(prototype, arena_);
  217|      4|    return reinterpret_cast<typename TypeHandler::Type*>(
  218|      4|        AddOutOfLineHelper(result));
  219|      4|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_15DescriptorProtoEE4sizeEv:
 1345|    216|inline int RepeatedPtrField<Element>::size() const {
 1346|    216|  return RepeatedPtrFieldBase::size();
 1347|    216|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_15DescriptorProtoEE5ClearEv:
 1505|     12|inline void RepeatedPtrField<Element>::Clear() {
 1506|     12|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 1507|     12|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldINS0_15DescriptorProtoEE11TypeHandlerEEEvv:
  284|     12|  void Clear() {
  285|     12|    const int n = current_size_;
  286|     12|    ABSL_DCHECK_GE(n, 0);
  ------------------
  |  |   78|     12|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|     12|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     12|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     12|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  287|     12|    if (n > 0) {
  ------------------
  |  Branch (287:9): [True: 0, False: 12]
  ------------------
  288|      0|      ClearNonEmpty<TypeHandler>();
  289|      0|    }
  290|     12|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldINS0_15DescriptorProtoEE11TypeHandlerEEEPNT_4TypeEPv:
  686|     96|  static inline typename TypeHandler::Type* cast(void* element) {
  687|     96|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  688|     96|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_15DescriptorProtoEE3GetEi:
 1351|     96|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1352|     96|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 1353|     96|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldINS0_15DescriptorProtoEE11TypeHandlerEEERKNT_4TypeEi:
  271|     96|  const typename TypeHandler::Type& Get(int index) const {
  272|     96|    ABSL_DCHECK_GE(index, 0);
  ------------------
  |  |   78|     96|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|     96|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     96|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     96|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  273|     96|    ABSL_DCHECK_LT(index, current_size_);
  ------------------
  |  |   76|     96|  ABSL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   92|     96|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     96|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     96|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  274|     96|    return *cast<TypeHandler>(rep_->elements[index]);
  275|     96|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_19EnumDescriptorProtoEE4sizeEv:
 1345|    120|inline int RepeatedPtrField<Element>::size() const {
 1346|    120|  return RepeatedPtrFieldBase::size();
 1347|    120|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_19EnumDescriptorProtoEE5ClearEv:
 1505|     12|inline void RepeatedPtrField<Element>::Clear() {
 1506|     12|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 1507|     12|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldINS0_19EnumDescriptorProtoEE11TypeHandlerEEEvv:
  284|     12|  void Clear() {
  285|     12|    const int n = current_size_;
  286|     12|    ABSL_DCHECK_GE(n, 0);
  ------------------
  |  |   78|     12|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|     12|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     12|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     12|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  287|     12|    if (n > 0) {
  ------------------
  |  Branch (287:9): [True: 0, False: 12]
  ------------------
  288|      0|      ClearNonEmpty<TypeHandler>();
  289|      0|    }
  290|     12|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldINS0_19EnumDescriptorProtoEE11TypeHandlerEEEPNT_4TypeEPv:
  686|     28|  static inline typename TypeHandler::Type* cast(void* element) {
  687|     28|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  688|     28|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_19EnumDescriptorProtoEE3GetEi:
 1351|     28|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1352|     28|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 1353|     28|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldINS0_19EnumDescriptorProtoEE11TypeHandlerEEERKNT_4TypeEi:
  271|     28|  const typename TypeHandler::Type& Get(int index) const {
  272|     28|    ABSL_DCHECK_GE(index, 0);
  ------------------
  |  |   78|     28|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|     28|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     28|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     28|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  273|     28|    ABSL_DCHECK_LT(index, current_size_);
  ------------------
  |  |   76|     28|  ABSL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   92|     28|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     28|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     28|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  274|     28|    return *cast<TypeHandler>(rep_->elements[index]);
  275|     28|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_22ServiceDescriptorProtoEE4sizeEv:
 1345|     24|inline int RepeatedPtrField<Element>::size() const {
 1346|     24|  return RepeatedPtrFieldBase::size();
 1347|     24|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_22ServiceDescriptorProtoEE5ClearEv:
 1505|     12|inline void RepeatedPtrField<Element>::Clear() {
 1506|     12|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 1507|     12|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldINS0_22ServiceDescriptorProtoEE11TypeHandlerEEEvv:
  284|     12|  void Clear() {
  285|     12|    const int n = current_size_;
  286|     12|    ABSL_DCHECK_GE(n, 0);
  ------------------
  |  |   78|     12|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|     12|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     12|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     12|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  287|     12|    if (n > 0) {
  ------------------
  |  Branch (287:9): [True: 0, False: 12]
  ------------------
  288|      0|      ClearNonEmpty<TypeHandler>();
  289|      0|    }
  290|     12|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEE4sizeEv:
 1345|    312|inline int RepeatedPtrField<Element>::size() const {
 1346|    312|  return RepeatedPtrFieldBase::size();
 1347|    312|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEE5ClearEv:
 1505|     12|inline void RepeatedPtrField<Element>::Clear() {
 1506|     12|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 1507|     12|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldINS0_20FieldDescriptorProtoEE11TypeHandlerEEEvv:
  284|     12|  void Clear() {
  285|     12|    const int n = current_size_;
  286|     12|    ABSL_DCHECK_GE(n, 0);
  ------------------
  |  |   78|     12|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|     12|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     12|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     12|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  287|     12|    if (n > 0) {
  ------------------
  |  Branch (287:9): [True: 0, False: 12]
  ------------------
  288|      0|      ClearNonEmpty<TypeHandler>();
  289|      0|    }
  290|     12|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldINS0_20FieldDescriptorProtoEE11TypeHandlerEEEPNT_4TypeEPv:
  686|    386|  static inline typename TypeHandler::Type* cast(void* element) {
  687|    386|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  688|    386|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEE3GetEi:
 1351|    386|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1352|    386|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 1353|    386|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldINS0_20FieldDescriptorProtoEE11TypeHandlerEEERKNT_4TypeEi:
  271|    386|  const typename TypeHandler::Type& Get(int index) const {
  272|    386|    ABSL_DCHECK_GE(index, 0);
  ------------------
  |  |   78|    386|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|    386|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|    386|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    386|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  273|    386|    ABSL_DCHECK_LT(index, current_size_);
  ------------------
  |  |   76|    386|  ABSL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   92|    386|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|    386|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    386|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  274|    386|    return *cast<TypeHandler>(rep_->elements[index]);
  275|    386|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_30DescriptorProto_ExtensionRangeEE4sizeEv:
 1345|     96|inline int RepeatedPtrField<Element>::size() const {
 1346|     96|  return RepeatedPtrFieldBase::size();
 1347|     96|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldINS0_30DescriptorProto_ExtensionRangeEE11TypeHandlerEEEPNT_4TypeEPv:
  686|     18|  static inline typename TypeHandler::Type* cast(void* element) {
  687|     18|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  688|     18|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_30DescriptorProto_ExtensionRangeEE3GetEi:
 1351|     18|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1352|     18|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 1353|     18|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldINS0_30DescriptorProto_ExtensionRangeEE11TypeHandlerEEERKNT_4TypeEi:
  271|     18|  const typename TypeHandler::Type& Get(int index) const {
  272|     18|    ABSL_DCHECK_GE(index, 0);
  ------------------
  |  |   78|     18|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|     18|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     18|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     18|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  273|     18|    ABSL_DCHECK_LT(index, current_size_);
  ------------------
  |  |   76|     18|  ABSL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   92|     18|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     18|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     18|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  274|     18|    return *cast<TypeHandler>(rep_->elements[index]);
  275|     18|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_20OneofDescriptorProtoEE4sizeEv:
 1345|     96|inline int RepeatedPtrField<Element>::size() const {
 1346|     96|  return RepeatedPtrFieldBase::size();
 1347|     96|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldINS0_20OneofDescriptorProtoEE11TypeHandlerEEEPNT_4TypeEPv:
  686|      2|  static inline typename TypeHandler::Type* cast(void* element) {
  687|      2|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  688|      2|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_20OneofDescriptorProtoEE3GetEi:
 1351|      2|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1352|      2|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 1353|      2|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldINS0_20OneofDescriptorProtoEE11TypeHandlerEEERKNT_4TypeEi:
  271|      2|  const typename TypeHandler::Type& Get(int index) const {
  272|      2|    ABSL_DCHECK_GE(index, 0);
  ------------------
  |  |   78|      2|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|      2|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|      2|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      2|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  273|      2|    ABSL_DCHECK_LT(index, current_size_);
  ------------------
  |  |   76|      2|  ABSL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   92|      2|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|      2|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      2|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  274|      2|    return *cast<TypeHandler>(rep_->elements[index]);
  275|      2|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_19UninterpretedOptionEE4sizeEv:
 1345|     32|inline int RepeatedPtrField<Element>::size() const {
 1346|     32|  return RepeatedPtrFieldBase::size();
 1347|     32|}
_ZNK6google8protobuf16RepeatedPtrFieldINS0_24EnumValueDescriptorProtoEE4sizeEv:
 1345|     28|inline int RepeatedPtrField<Element>::size() const {
 1346|     28|  return RepeatedPtrFieldBase::size();
 1347|     28|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldINS0_24EnumValueDescriptorProtoEE11TypeHandlerEEEPNT_4TypeEPv:
  686|    156|  static inline typename TypeHandler::Type* cast(void* element) {
  687|    156|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  688|    156|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_24EnumValueDescriptorProtoEE3GetEi:
 1351|    156|    ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1352|    156|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 1353|    156|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldINS0_24EnumValueDescriptorProtoEE11TypeHandlerEEERKNT_4TypeEi:
  271|    156|  const typename TypeHandler::Type& Get(int index) const {
  272|    156|    ABSL_DCHECK_GE(index, 0);
  ------------------
  |  |   78|    156|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|    156|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|    156|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    156|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  273|    156|    ABSL_DCHECK_LT(index, current_size_);
  ------------------
  |  |   76|    156|  ABSL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   92|    156|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|    156|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    156|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  274|    156|    return *cast<TypeHandler>(rep_->elements[index]);
  275|    156|  }
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPNS0_5ArenaE:
 1262|    136|    : RepeatedPtrFieldBase(arena) {
 1263|    136|  StaticValidityCheck();
 1264|    136|}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE19StaticValidityCheckEv:
  914|    272|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  915|    272|    static_assert(
  916|    272|        absl::disjunction<
  917|    272|            internal::is_supported_string_type<Element>,
  918|    272|            internal::is_supported_message_type<Element>>::value,
  919|    272|        "We only support string and Message types in RepeatedPtrField.");
  920|    272|  }
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEED2Ev:
 1282|    136|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1283|    136|  StaticValidityCheck();
 1284|       |#ifdef __cpp_if_constexpr
 1285|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1286|       |#else
 1287|    136|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|      0|#endif
 1289|      0|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1289:9): [True: 0, False: 0]
  ------------------
 1290|    136|  } else {
 1291|    136|    Destroy<TypeHandler>();
 1292|    136|  }
 1293|    136|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7DestroyINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEvv:
  249|    136|  void Destroy() {
  250|    136|    if (rep_ != nullptr && arena_ == nullptr) {
  ------------------
  |  Branch (250:9): [True: 2, False: 134]
  |  Branch (250:28): [True: 2, False: 0]
  ------------------
  251|      2|      int n = rep_->allocated_size;
  252|      2|      void* const* elements = rep_->elements;
  253|      6|      for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (253:23): [True: 4, False: 2]
  ------------------
  254|      4|        TypeHandler::Delete(cast<TypeHandler>(elements[i]), nullptr);
  255|      4|      }
  256|      2|      const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
  257|      2|      internal::SizedDelete(rep_, size);
  258|      2|    }
  259|    136|    rep_ = nullptr;
  260|    136|  }
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE14GetOwningArenaEv:
 1588|      2|inline Arena* RepeatedPtrField<Element>::GetOwningArena() const {
 1589|      2|  return RepeatedPtrFieldBase::GetOwningArena();
 1590|      2|}
_ZNK6google8protobuf16RepeatedPtrFieldINS0_22ServiceDescriptorProtoEE5beginEv:
 1872|     12|RepeatedPtrField<Element>::begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1873|     12|  return iterator(raw_data());
 1874|     12|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorINS0_22ServiceDescriptorProtoEEC2EPKPv:
 1670|     24|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKNS0_22ServiceDescriptorProtoEEC2IS3_LPv0EEERKNS2_IT_EE:
 1678|     24|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldINS0_22ServiceDescriptorProtoEE3endEv:
 1887|     12|RepeatedPtrField<Element>::end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1888|     12|  return iterator(raw_data() + size());
 1889|     12|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKNS0_22ServiceDescriptorProtoEEES7_:
 1700|     12|  friend bool operator!=(const iterator& x, const iterator& y) {
 1701|     12|    return x.it_ != y.it_;
 1702|     12|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_15DescriptorProtoEE5beginEv:
 1872|    108|RepeatedPtrField<Element>::begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1873|    108|  return iterator(raw_data());
 1874|    108|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorINS0_15DescriptorProtoEEC2EPKPv:
 1670|    216|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKNS0_15DescriptorProtoEEC2IS3_LPv0EEERKNS2_IT_EE:
 1678|    216|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldINS0_15DescriptorProtoEE3endEv:
 1887|    108|RepeatedPtrField<Element>::end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1888|    108|  return iterator(raw_data() + size());
 1889|    108|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKNS0_15DescriptorProtoEEES7_:
 1700|    204|  friend bool operator!=(const iterator& x, const iterator& y) {
 1701|    204|    return x.it_ != y.it_;
 1702|    204|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKNS0_15DescriptorProtoEEdeEv:
 1681|     96|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKNS0_15DescriptorProtoEEppEv:
 1685|     96|  iterator& operator++() {
 1686|     96|    ++it_;
 1687|     96|    return *this;
 1688|     96|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_19EnumDescriptorProtoEE5beginEv:
 1872|     12|RepeatedPtrField<Element>::begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1873|     12|  return iterator(raw_data());
 1874|     12|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorINS0_19EnumDescriptorProtoEEC2EPKPv:
 1670|     24|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKNS0_19EnumDescriptorProtoEEC2IS3_LPv0EEERKNS2_IT_EE:
 1678|     24|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldINS0_19EnumDescriptorProtoEE3endEv:
 1887|     12|RepeatedPtrField<Element>::end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1888|     12|  return iterator(raw_data() + size());
 1889|     12|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKNS0_19EnumDescriptorProtoEEES7_:
 1700|     16|  friend bool operator!=(const iterator& x, const iterator& y) {
 1701|     16|    return x.it_ != y.it_;
 1702|     16|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKNS0_19EnumDescriptorProtoEEdeEv:
 1681|      4|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKNS0_19EnumDescriptorProtoEEppEv:
 1685|      4|  iterator& operator++() {
 1686|      4|    ++it_;
 1687|      4|    return *this;
 1688|      4|  }
_ZNK6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEE5beginEv:
 1872|    108|RepeatedPtrField<Element>::begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1873|    108|  return iterator(raw_data());
 1874|    108|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorINS0_20FieldDescriptorProtoEEC2EPKPv:
 1670|    216|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKNS0_20FieldDescriptorProtoEEC2IS3_LPv0EEERKNS2_IT_EE:
 1678|    216|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEE3endEv:
 1887|    108|RepeatedPtrField<Element>::end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 1888|    108|  return iterator(raw_data() + size());
 1889|    108|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKNS0_20FieldDescriptorProtoEEES7_:
 1700|    108|  friend bool operator!=(const iterator& x, const iterator& y) {
 1701|    108|    return x.it_ != y.it_;
 1702|    108|  }
_ZN6google8protobuf16RepeatedPtrFieldINS0_15DescriptorProtoEEC2EPNS0_5ArenaE:
 1262|    108|    : RepeatedPtrFieldBase(arena) {
 1263|    108|  StaticValidityCheck();
 1264|    108|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_15DescriptorProtoEE19StaticValidityCheckEv:
  914|    216|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  915|    216|    static_assert(
  916|    216|        absl::disjunction<
  917|    216|            internal::is_supported_string_type<Element>,
  918|    216|            internal::is_supported_message_type<Element>>::value,
  919|    216|        "We only support string and Message types in RepeatedPtrField.");
  920|    216|  }
_ZN6google8protobuf16RepeatedPtrFieldINS0_19EnumDescriptorProtoEEC2EPNS0_5ArenaE:
 1262|    108|    : RepeatedPtrFieldBase(arena) {
 1263|    108|  StaticValidityCheck();
 1264|    108|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_19EnumDescriptorProtoEE19StaticValidityCheckEv:
  914|    216|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  915|    216|    static_assert(
  916|    216|        absl::disjunction<
  917|    216|            internal::is_supported_string_type<Element>,
  918|    216|            internal::is_supported_message_type<Element>>::value,
  919|    216|        "We only support string and Message types in RepeatedPtrField.");
  920|    216|  }
_ZN6google8protobuf16RepeatedPtrFieldINS0_22ServiceDescriptorProtoEEC2EPNS0_5ArenaE:
 1262|     12|    : RepeatedPtrFieldBase(arena) {
 1263|     12|  StaticValidityCheck();
 1264|     12|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_22ServiceDescriptorProtoEE19StaticValidityCheckEv:
  914|     24|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  915|     24|    static_assert(
  916|     24|        absl::disjunction<
  917|     24|            internal::is_supported_string_type<Element>,
  918|     24|            internal::is_supported_message_type<Element>>::value,
  919|     24|        "We only support string and Message types in RepeatedPtrField.");
  920|     24|  }
_ZN6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEEC2EPNS0_5ArenaE:
 1262|    204|    : RepeatedPtrFieldBase(arena) {
 1263|    204|  StaticValidityCheck();
 1264|    204|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEE19StaticValidityCheckEv:
  914|    408|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  915|    408|    static_assert(
  916|    408|        absl::disjunction<
  917|    408|            internal::is_supported_string_type<Element>,
  918|    408|            internal::is_supported_message_type<Element>>::value,
  919|    408|        "We only support string and Message types in RepeatedPtrField.");
  920|    408|  }
_ZN6google8protobuf16RepeatedPtrFieldINS0_30DescriptorProto_ExtensionRangeEEC2EPNS0_5ArenaE:
 1262|     96|    : RepeatedPtrFieldBase(arena) {
 1263|     96|  StaticValidityCheck();
 1264|     96|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_30DescriptorProto_ExtensionRangeEE19StaticValidityCheckEv:
  914|    192|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  915|    192|    static_assert(
  916|    192|        absl::disjunction<
  917|    192|            internal::is_supported_string_type<Element>,
  918|    192|            internal::is_supported_message_type<Element>>::value,
  919|    192|        "We only support string and Message types in RepeatedPtrField.");
  920|    192|  }
_ZN6google8protobuf16RepeatedPtrFieldINS0_20OneofDescriptorProtoEEC2EPNS0_5ArenaE:
 1262|     96|    : RepeatedPtrFieldBase(arena) {
 1263|     96|  StaticValidityCheck();
 1264|     96|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_20OneofDescriptorProtoEE19StaticValidityCheckEv:
  914|    192|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  915|    192|    static_assert(
  916|    192|        absl::disjunction<
  917|    192|            internal::is_supported_string_type<Element>,
  918|    192|            internal::is_supported_message_type<Element>>::value,
  919|    192|        "We only support string and Message types in RepeatedPtrField.");
  920|    192|  }
_ZN6google8protobuf16RepeatedPtrFieldINS0_29DescriptorProto_ReservedRangeEEC2EPNS0_5ArenaE:
 1262|     96|    : RepeatedPtrFieldBase(arena) {
 1263|     96|  StaticValidityCheck();
 1264|     96|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_29DescriptorProto_ReservedRangeEE19StaticValidityCheckEv:
  914|    192|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  915|    192|    static_assert(
  916|    192|        absl::disjunction<
  917|    192|            internal::is_supported_string_type<Element>,
  918|    192|            internal::is_supported_message_type<Element>>::value,
  919|    192|        "We only support string and Message types in RepeatedPtrField.");
  920|    192|  }
_ZN6google8protobuf16RepeatedPtrFieldINS0_19UninterpretedOptionEEC2EPNS0_5ArenaE:
 1262|     32|    : RepeatedPtrFieldBase(arena) {
 1263|     32|  StaticValidityCheck();
 1264|     32|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_19UninterpretedOptionEE19StaticValidityCheckEv:
  914|     64|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  915|     64|    static_assert(
  916|     64|        absl::disjunction<
  917|     64|            internal::is_supported_string_type<Element>,
  918|     64|            internal::is_supported_message_type<Element>>::value,
  919|     64|        "We only support string and Message types in RepeatedPtrField.");
  920|     64|  }
_ZN6google8protobuf16RepeatedPtrFieldINS0_19UninterpretedOptionEED2Ev:
 1282|     32|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1283|     32|  StaticValidityCheck();
 1284|       |#ifdef __cpp_if_constexpr
 1285|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1286|       |#else
 1287|     32|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|     32|#endif
 1289|     32|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1289:9): [True: 0, False: 32]
  ------------------
 1290|     32|  } else {
 1291|      0|    Destroy<TypeHandler>();
 1292|      0|  }
 1293|     32|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_24EnumValueDescriptorProtoEEC2EPNS0_5ArenaE:
 1262|     28|    : RepeatedPtrFieldBase(arena) {
 1263|     28|  StaticValidityCheck();
 1264|     28|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_24EnumValueDescriptorProtoEE19StaticValidityCheckEv:
  914|     56|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  915|     56|    static_assert(
  916|     56|        absl::disjunction<
  917|     56|            internal::is_supported_string_type<Element>,
  918|     56|            internal::is_supported_message_type<Element>>::value,
  919|     56|        "We only support string and Message types in RepeatedPtrField.");
  920|     56|  }
_ZN6google8protobuf16RepeatedPtrFieldINS0_37EnumDescriptorProto_EnumReservedRangeEEC2EPNS0_5ArenaE:
 1262|     28|    : RepeatedPtrFieldBase(arena) {
 1263|     28|  StaticValidityCheck();
 1264|     28|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_37EnumDescriptorProto_EnumReservedRangeEE19StaticValidityCheckEv:
  914|     56|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  915|     56|    static_assert(
  916|     56|        absl::disjunction<
  917|     56|            internal::is_supported_string_type<Element>,
  918|     56|            internal::is_supported_message_type<Element>>::value,
  919|     56|        "We only support string and Message types in RepeatedPtrField.");
  920|     56|  }
_ZN6google8protobuf16RepeatedPtrFieldINS0_15DescriptorProtoEED2Ev:
 1282|    108|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1283|    108|  StaticValidityCheck();
 1284|       |#ifdef __cpp_if_constexpr
 1285|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1286|       |#else
 1287|    108|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|    108|#endif
 1289|    108|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1289:9): [True: 26, False: 82]
  ------------------
 1290|    108|  } else {
 1291|      0|    Destroy<TypeHandler>();
 1292|      0|  }
 1293|    108|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_19EnumDescriptorProtoEED2Ev:
 1282|    108|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1283|    108|  StaticValidityCheck();
 1284|       |#ifdef __cpp_if_constexpr
 1285|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1286|       |#else
 1287|    108|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|    108|#endif
 1289|    108|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1289:9): [True: 18, False: 90]
  ------------------
 1290|    108|  } else {
 1291|      0|    Destroy<TypeHandler>();
 1292|      0|  }
 1293|    108|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_22ServiceDescriptorProtoEED2Ev:
 1282|     12|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1283|     12|  StaticValidityCheck();
 1284|       |#ifdef __cpp_if_constexpr
 1285|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1286|       |#else
 1287|     12|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|     12|#endif
 1289|     12|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1289:9): [True: 0, False: 12]
  ------------------
 1290|     12|  } else {
 1291|      0|    Destroy<TypeHandler>();
 1292|      0|  }
 1293|     12|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEED2Ev:
 1282|    204|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1283|    204|  StaticValidityCheck();
 1284|       |#ifdef __cpp_if_constexpr
 1285|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1286|       |#else
 1287|    204|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|    204|#endif
 1289|    204|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1289:9): [True: 96, False: 108]
  ------------------
 1290|    204|  } else {
 1291|      0|    Destroy<TypeHandler>();
 1292|      0|  }
 1293|    204|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_30DescriptorProto_ExtensionRangeEED2Ev:
 1282|     96|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1283|     96|  StaticValidityCheck();
 1284|       |#ifdef __cpp_if_constexpr
 1285|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1286|       |#else
 1287|     96|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|     96|#endif
 1289|     96|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1289:9): [True: 18, False: 78]
  ------------------
 1290|     96|  } else {
 1291|      0|    Destroy<TypeHandler>();
 1292|      0|  }
 1293|     96|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_20OneofDescriptorProtoEED2Ev:
 1282|     96|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1283|     96|  StaticValidityCheck();
 1284|       |#ifdef __cpp_if_constexpr
 1285|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1286|       |#else
 1287|     96|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|     96|#endif
 1289|     96|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1289:9): [True: 2, False: 94]
  ------------------
 1290|     96|  } else {
 1291|      0|    Destroy<TypeHandler>();
 1292|      0|  }
 1293|     96|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_29DescriptorProto_ReservedRangeEED2Ev:
 1282|     96|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1283|     96|  StaticValidityCheck();
 1284|       |#ifdef __cpp_if_constexpr
 1285|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1286|       |#else
 1287|     96|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|     96|#endif
 1289|     96|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1289:9): [True: 8, False: 88]
  ------------------
 1290|     96|  } else {
 1291|      0|    Destroy<TypeHandler>();
 1292|      0|  }
 1293|     96|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_24EnumValueDescriptorProtoEED2Ev:
 1282|     28|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1283|     28|  StaticValidityCheck();
 1284|       |#ifdef __cpp_if_constexpr
 1285|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1286|       |#else
 1287|     28|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|     28|#endif
 1289|     28|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1289:9): [True: 28, False: 0]
  ------------------
 1290|     28|  } else {
 1291|      0|    Destroy<TypeHandler>();
 1292|      0|  }
 1293|     28|}
_ZN6google8protobuf16RepeatedPtrFieldINS0_37EnumDescriptorProto_EnumReservedRangeEED2Ev:
 1282|     28|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1283|     28|  StaticValidityCheck();
 1284|       |#ifdef __cpp_if_constexpr
 1285|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1286|       |#else
 1287|     28|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|     28|#endif
 1289|     28|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1289:9): [True: 0, False: 28]
  ------------------
 1290|     28|  } else {
 1291|      0|    Destroy<TypeHandler>();
 1292|      0|  }
 1293|     28|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS1_18GenericTypeHandlerINS0_11MessageLiteEEEEEPNT_4TypeEPKS8_:
  210|    702|      const typename TypeHandler::Type* prototype = nullptr) {
  211|    702|    if (rep_ != nullptr && current_size_ < rep_->allocated_size) {
  ------------------
  |  Branch (211:9): [True: 506, False: 196]
  |  Branch (211:28): [True: 0, False: 506]
  ------------------
  212|      0|      return cast<TypeHandler>(
  213|      0|          rep_->elements[ExchangeCurrentSize(current_size_ + 1)]);
  214|      0|    }
  215|    702|    typename TypeHandler::Type* result =
  216|    702|        TypeHandler::NewFromPrototype(prototype, arena_);
  217|    702|    return reinterpret_cast<typename TypeHandler::Type*>(
  218|    702|        AddOutOfLineHelper(result));
  219|    702|  }

_ZN6google8protobuf19FileDescriptorProtoC2Ev:
  694|     12|  inline FileDescriptorProto() : FileDescriptorProto(nullptr) {}
_ZN6google8protobuf19FileDescriptorProto25internal_default_instanceEv:
  742|     24|  static inline const FileDescriptorProto* internal_default_instance() {
  743|     24|    return reinterpret_cast<const FileDescriptorProto*>(
  744|     24|               &_FileDescriptorProto_default_instance_);
  745|     24|  }
_ZN6google8protobuf30DescriptorProto_ExtensionRange25internal_default_instanceEv:
 1148|     18|  static inline const DescriptorProto_ExtensionRange* internal_default_instance() {
 1149|     18|    return reinterpret_cast<const DescriptorProto_ExtensionRange*>(
 1150|     18|               &_DescriptorProto_ExtensionRange_default_instance_);
 1151|     18|  }
_ZNK6google8protobuf30DescriptorProto_ExtensionRange3NewEPNS0_5ArenaE:
 1179|     18|  DescriptorProto_ExtensionRange* New(::google::protobuf::Arena* arena = nullptr) const final {
 1180|     18|    return CreateMaybeMessage<DescriptorProto_ExtensionRange>(arena);
 1181|     18|  }
_ZNK6google8protobuf29DescriptorProto_ReservedRange3NewEPNS0_5ArenaE:
 1368|     16|  DescriptorProto_ReservedRange* New(::google::protobuf::Arena* arena = nullptr) const final {
 1369|     16|    return CreateMaybeMessage<DescriptorProto_ReservedRange>(arena);
 1370|     16|  }
_ZN6google8protobuf15DescriptorProto25internal_default_instanceEv:
 1509|     96|  static inline const DescriptorProto* internal_default_instance() {
 1510|     96|    return reinterpret_cast<const DescriptorProto*>(
 1511|     96|               &_DescriptorProto_default_instance_);
 1512|     96|  }
_ZNK6google8protobuf15DescriptorProto3NewEPNS0_5ArenaE:
 1540|     96|  DescriptorProto* New(::google::protobuf::Arena* arena = nullptr) const final {
 1541|     96|    return CreateMaybeMessage<DescriptorProto>(arena);
 1542|     96|  }
_ZN6google8protobuf20FieldDescriptorProto25internal_default_instanceEv:
 2474|    386|  static inline const FieldDescriptorProto* internal_default_instance() {
 2475|    386|    return reinterpret_cast<const FieldDescriptorProto*>(
 2476|    386|               &_FieldDescriptorProto_default_instance_);
 2477|    386|  }
_ZNK6google8protobuf20FieldDescriptorProto3NewEPNS0_5ArenaE:
 2505|    386|  FieldDescriptorProto* New(::google::protobuf::Arena* arena = nullptr) const final {
 2506|    386|    return CreateMaybeMessage<FieldDescriptorProto>(arena);
 2507|    386|  }
_ZN6google8protobuf20OneofDescriptorProto25internal_default_instanceEv:
 2854|      2|  static inline const OneofDescriptorProto* internal_default_instance() {
 2855|      2|    return reinterpret_cast<const OneofDescriptorProto*>(
 2856|      2|               &_OneofDescriptorProto_default_instance_);
 2857|      2|  }
_ZNK6google8protobuf20OneofDescriptorProto3NewEPNS0_5ArenaE:
 2885|      2|  OneofDescriptorProto* New(::google::protobuf::Arena* arena = nullptr) const final {
 2886|      2|    return CreateMaybeMessage<OneofDescriptorProto>(arena);
 2887|      2|  }
_ZN6google8protobuf19EnumDescriptorProto25internal_default_instanceEv:
 3208|     28|  static inline const EnumDescriptorProto* internal_default_instance() {
 3209|     28|    return reinterpret_cast<const EnumDescriptorProto*>(
 3210|     28|               &_EnumDescriptorProto_default_instance_);
 3211|     28|  }
_ZNK6google8protobuf19EnumDescriptorProto3NewEPNS0_5ArenaE:
 3239|     28|  EnumDescriptorProto* New(::google::protobuf::Arena* arena = nullptr) const final {
 3240|     28|    return CreateMaybeMessage<EnumDescriptorProto>(arena);
 3241|     28|  }
_ZN6google8protobuf24EnumValueDescriptorProto25internal_default_instanceEv:
 3462|    156|  static inline const EnumValueDescriptorProto* internal_default_instance() {
 3463|    156|    return reinterpret_cast<const EnumValueDescriptorProto*>(
 3464|    156|               &_EnumValueDescriptorProto_default_instance_);
 3465|    156|  }
_ZNK6google8protobuf24EnumValueDescriptorProto3NewEPNS0_5ArenaE:
 3493|    156|  EnumValueDescriptorProto* New(::google::protobuf::Arena* arena = nullptr) const final {
 3494|    156|    return CreateMaybeMessage<EnumValueDescriptorProto>(arena);
 3495|    156|  }
_ZN6google8protobuf11FileOptions25internal_default_instanceEv:
 4105|     12|  static inline const FileOptions* internal_default_instance() {
 4106|     12|    return reinterpret_cast<const FileOptions*>(
 4107|     12|               &_FileOptions_default_instance_);
 4108|     12|  }
_ZNK6google8protobuf11FileOptions3NewEPNS0_5ArenaE:
 4136|     12|  FileOptions* New(::google::protobuf::Arena* arena = nullptr) const final {
 4137|     12|    return CreateMaybeMessage<FileOptions>(arena);
 4138|     12|  }
_ZN6google8protobuf14MessageOptions25internal_default_instanceEv:
 4765|      2|  static inline const MessageOptions* internal_default_instance() {
 4766|      2|    return reinterpret_cast<const MessageOptions*>(
 4767|      2|               &_MessageOptions_default_instance_);
 4768|      2|  }
_ZNK6google8protobuf14MessageOptions3NewEPNS0_5ArenaE:
 4796|      2|  MessageOptions* New(::google::protobuf::Arena* arena = nullptr) const final {
 4797|      2|    return CreateMaybeMessage<MessageOptions>(arena);
 4798|      2|  }
_ZN6google8protobuf12FieldOptions25internal_default_instanceEv:
 5149|     18|  static inline const FieldOptions* internal_default_instance() {
 5150|     18|    return reinterpret_cast<const FieldOptions*>(
 5151|     18|               &_FieldOptions_default_instance_);
 5152|     18|  }
_ZNK6google8protobuf12FieldOptions3NewEPNS0_5ArenaE:
 5180|     18|  FieldOptions* New(::google::protobuf::Arena* arena = nullptr) const final {
 5181|     18|    return CreateMaybeMessage<FieldOptions>(arena);
 5182|     18|  }
_ZNK6google8protobuf19FileDescriptorProto4nameEv:
 8727|    104|inline const std::string& FileDescriptorProto::name() const {
 8728|       |  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.name)
 8729|    104|  return _internal_name();
 8730|    104|}
_ZNK6google8protobuf19FileDescriptorProto14_internal_nameEv:
 8743|    104|inline const std::string& FileDescriptorProto::_internal_name() const {
 8744|    104|  return _impl_.name_.Get();
 8745|    104|}
_ZNK6google8protobuf19FileDescriptorProto7packageEv:
 8790|     24|inline const std::string& FileDescriptorProto::package() const {
 8791|       |  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.package)
 8792|     24|  return _internal_package();
 8793|     24|}
_ZNK6google8protobuf19FileDescriptorProto17_internal_packageEv:
 8806|     24|inline const std::string& FileDescriptorProto::_internal_package() const {
 8807|     24|  return _impl_.package_.Get();
 8808|     24|}
_ZN6google8protobuf19FileDescriptorProto28_internal_mutable_dependencyEv:
 8927|     24|FileDescriptorProto::_internal_mutable_dependency() {
 8928|     24|  return &_impl_.dependency_;
 8929|     24|}
_ZN6google8protobuf19FileDescriptorProto35_internal_mutable_public_dependencyEv:
 8965|     12|inline ::google::protobuf::RepeatedField<::int32_t>* FileDescriptorProto::_internal_mutable_public_dependency() {
 8966|     12|  return &_impl_.public_dependency_;
 8967|     12|}
_ZN6google8protobuf19FileDescriptorProto33_internal_mutable_weak_dependencyEv:
 9003|     12|inline ::google::protobuf::RepeatedField<::int32_t>* FileDescriptorProto::_internal_mutable_weak_dependency() {
 9004|     12|  return &_impl_.weak_dependency_;
 9005|     12|}
_ZNK6google8protobuf19FileDescriptorProto12message_typeEv:
 9036|     12|FileDescriptorProto::message_type() const {
 9037|       |  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.message_type)
 9038|     12|  return _internal_message_type();
 9039|     12|}
_ZNK6google8protobuf19FileDescriptorProto22_internal_message_typeEv:
 9041|     24|FileDescriptorProto::_internal_message_type() const {
 9042|     24|  return _impl_.message_type_;
 9043|     24|}
_ZN6google8protobuf19FileDescriptorProto30_internal_mutable_message_typeEv:
 9045|     12|FileDescriptorProto::_internal_mutable_message_type() {
 9046|     12|  return &_impl_.message_type_;
 9047|     12|}
_ZNK6google8protobuf19FileDescriptorProto9enum_typeEv:
 9078|     12|FileDescriptorProto::enum_type() const {
 9079|       |  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.enum_type)
 9080|     12|  return _internal_enum_type();
 9081|     12|}
_ZNK6google8protobuf19FileDescriptorProto19_internal_enum_typeEv:
 9083|     24|FileDescriptorProto::_internal_enum_type() const {
 9084|     24|  return _impl_.enum_type_;
 9085|     24|}
_ZN6google8protobuf19FileDescriptorProto27_internal_mutable_enum_typeEv:
 9087|     12|FileDescriptorProto::_internal_mutable_enum_type() {
 9088|     12|  return &_impl_.enum_type_;
 9089|     12|}
_ZNK6google8protobuf19FileDescriptorProto7serviceEv:
 9120|     12|FileDescriptorProto::service() const {
 9121|       |  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.service)
 9122|     12|  return _internal_service();
 9123|     12|}
_ZNK6google8protobuf19FileDescriptorProto17_internal_serviceEv:
 9125|     24|FileDescriptorProto::_internal_service() const {
 9126|     24|  return _impl_.service_;
 9127|     24|}
_ZN6google8protobuf19FileDescriptorProto25_internal_mutable_serviceEv:
 9129|     12|FileDescriptorProto::_internal_mutable_service() {
 9130|     12|  return &_impl_.service_;
 9131|     12|}
_ZNK6google8protobuf19FileDescriptorProto9extensionEv:
 9162|     12|FileDescriptorProto::extension() const {
 9163|       |  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.extension)
 9164|     12|  return _internal_extension();
 9165|     12|}
_ZNK6google8protobuf19FileDescriptorProto19_internal_extensionEv:
 9167|     24|FileDescriptorProto::_internal_extension() const {
 9168|     24|  return _impl_.extension_;
 9169|     24|}
_ZN6google8protobuf19FileDescriptorProto27_internal_mutable_extensionEv:
 9171|     12|FileDescriptorProto::_internal_mutable_extension() {
 9172|     12|  return &_impl_.extension_;
 9173|     12|}
_ZNK6google8protobuf15DescriptorProto4nameEv:
 9692|     80|inline const std::string& DescriptorProto::name() const {
 9693|       |  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.name)
 9694|     80|  return _internal_name();
 9695|     80|}
_ZNK6google8protobuf15DescriptorProto14_internal_nameEv:
 9708|     80|inline const std::string& DescriptorProto::_internal_name() const {
 9709|     80|  return _impl_.name_.Get();
 9710|     80|}
_ZNK6google8protobuf15DescriptorProto15_internal_fieldEv:
 9780|     96|DescriptorProto::_internal_field() const {
 9781|     96|  return _impl_.field_;
 9782|     96|}
_ZNK6google8protobuf15DescriptorProto9extensionEv:
 9817|     96|DescriptorProto::extension() const {
 9818|       |  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.extension)
 9819|     96|  return _internal_extension();
 9820|     96|}
_ZNK6google8protobuf15DescriptorProto19_internal_extensionEv:
 9822|    192|DescriptorProto::_internal_extension() const {
 9823|    192|  return _impl_.extension_;
 9824|    192|}
_ZNK6google8protobuf15DescriptorProto11nested_typeEv:
 9859|     96|DescriptorProto::nested_type() const {
 9860|       |  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.nested_type)
 9861|     96|  return _internal_nested_type();
 9862|     96|}
_ZNK6google8protobuf15DescriptorProto21_internal_nested_typeEv:
 9864|    192|DescriptorProto::_internal_nested_type() const {
 9865|    192|  return _impl_.nested_type_;
 9866|    192|}
_ZNK6google8protobuf15DescriptorProto19_internal_enum_typeEv:
 9906|     96|DescriptorProto::_internal_enum_type() const {
 9907|     96|  return _impl_.enum_type_;
 9908|     96|}
_ZNK6google8protobuf15DescriptorProto25_internal_extension_rangeEv:
 9948|     96|DescriptorProto::_internal_extension_range() const {
 9949|     96|  return _impl_.extension_range_;
 9950|     96|}
_ZNK6google8protobuf15DescriptorProto20_internal_oneof_declEv:
 9990|     96|DescriptorProto::_internal_oneof_decl() const {
 9991|     96|  return _impl_.oneof_decl_;
 9992|     96|}
_ZN6google8protobuf15DescriptorProto31_internal_mutable_reserved_nameEv:
10213|     96|DescriptorProto::_internal_mutable_reserved_name() {
10214|     96|  return &_impl_.reserved_name_;
10215|     96|}
_ZNK6google8protobuf19EnumDescriptorProto4nameEv:
11321|      4|inline const std::string& EnumDescriptorProto::name() const {
11322|       |  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.name)
11323|      4|  return _internal_name();
11324|      4|}
_ZNK6google8protobuf19EnumDescriptorProto14_internal_nameEv:
11337|      4|inline const std::string& EnumDescriptorProto::_internal_name() const {
11338|      4|  return _impl_.name_.Get();
11339|      4|}
_ZNK6google8protobuf19EnumDescriptorProto15_internal_valueEv:
11409|     28|EnumDescriptorProto::_internal_value() const {
11410|     28|  return _impl_.value_;
11411|     28|}
_ZN6google8protobuf19EnumDescriptorProto31_internal_mutable_reserved_nameEv:
11632|     28|EnumDescriptorProto::_internal_mutable_reserved_name() {
11633|     28|  return &_impl_.reserved_name_;
11634|     28|}
_ZNK6google8protobuf11FileOptions30_internal_uninterpreted_optionEv:
13269|     12|FileOptions::_internal_uninterpreted_option() const {
13270|     12|  return _impl_.uninterpreted_option_;
13271|     12|}
_ZNK6google8protobuf14MessageOptions30_internal_uninterpreted_optionEv:
13440|      2|MessageOptions::_internal_uninterpreted_option() const {
13441|      2|  return _impl_.uninterpreted_option_;
13442|      2|}
_ZN6google8protobuf12FieldOptions25_internal_mutable_targetsEv:
13715|     18|inline ::google::protobuf::RepeatedField<int>* FieldOptions::_internal_mutable_targets() {
13716|     18|  return &_impl_.targets_;
13717|     18|}
_ZNK6google8protobuf12FieldOptions30_internal_uninterpreted_optionEv:
13753|     18|FieldOptions::_internal_uninterpreted_option() const {
13754|     18|  return _impl_.uninterpreted_option_;
13755|     18|}

_ZN6google8protobuf18DescriptorDatabaseC2Ev:
   75|      2|  inline DescriptorDatabase() {}

_ZN6google8protobuf7MessageC2EPNS0_5ArenaE:
  418|    746|  inline explicit Message(Arena* arena) : MessageLite(arena) {}
_ZN6google8protobuf14MessageFactoryC2Ev:
 1344|      2|  inline MessageFactory() {}

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

_ZN6google8protobuf2io16CodedInputStream24GetDefaultRecursionLimitEv:
  406|     12|  static int GetDefaultRecursionLimit() { return default_recursion_limit_; }

_ZN6google8protobuf2io19ZeroCopyInputStreamC2Ev:
  130|  54.9k|  ZeroCopyInputStream() {}
_ZN6google8protobuf2io19ZeroCopyInputStreamD2Ev:
  133|  54.9k|  virtual ~ZeroCopyInputStream() {}

_ZN4absl12lts_2023012513base_internal10PrefetchT2EPKv:
  101|     12|inline void PrefetchT2(const void* addr) {
  102|       |  // Note: this uses prefetcht2 on Intel.
  103|     12|  __builtin_prefetch(addr, 0, 1);
  104|     12|}

_ZN4absl12lts_2023012513base_internal15UnalignedLoad32EPKv:
   44|     48|inline uint32_t UnalignedLoad32(const void *p) {
   45|     48|  uint32_t t;
   46|     48|  memcpy(&t, p, sizeof t);
   47|     48|  return t;
   48|     48|}
_ZN4absl12lts_2023012513base_internal15UnalignedLoad64EPKv:
   50|     80|inline uint64_t UnalignedLoad64(const void *p) {
   51|     80|  uint64_t t;
   52|     80|  memcpy(&t, p, sizeof t);
   53|     80|  return t;
   54|     80|}

_ZN4absl12lts_2023012518container_internal15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEE7destroyINSt3__19allocatorIS7_EEEEvPT_PS7_:
  794|    442|  static void destroy(Alloc *alloc, slot_type *slot) {
  795|    442|    absl::allocator_traits<Alloc>::destroy(*alloc, slot);
  796|    442|  }
_ZN4absl12lts_2023012518container_internal15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEE7destroyINSt3__19allocatorIS7_EEEEvPT_PS7_:
  794|     26|  static void destroy(Alloc *alloc, slot_type *slot) {
  795|     26|    absl::allocator_traits<Alloc>::destroy(*alloc, slot);
  796|     26|  }
_ZN4absl12lts_2023012518container_internal10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS6_11FileCompareENSt3__19allocatorIS7_EELi256ELb0EE3keyEPKS7_:
  812|     26|  static const Key &key(const slot_type *slot) { return *slot; }
_ZN4absl12lts_2023012518container_internal15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEE9constructINSt3__19allocatorIS7_EEJS7_EEEvPT_PS7_DpOT0_:
  778|     38|  static void construct(Alloc *alloc, slot_type *slot, Args &&...args) {
  779|     38|    absl::allocator_traits<Alloc>::construct(*alloc, slot,
  780|     38|                                             std::forward<Args>(args)...);
  781|     38|  }
_ZN4absl12lts_2023012518container_internal15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEE7elementEPS7_:
  774|     26|  static value_type &element(slot_type *slot) { return *slot; }
_ZN4absl12lts_2023012518container_internal10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS6_11FileCompareENSt3__19allocatorIS7_EELi256ELb0EE3keyIS7_EERKT_SG_:
  809|     12|  static const V &key(const V &value) {
  810|     12|    return value;
  811|     12|  }
_ZN4absl12lts_2023012518container_internal10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS6_13SymbolCompareENSt3__19allocatorIS7_EELi256ELb0EE3keyEPKS7_:
  812|    526|  static const Key &key(const slot_type *slot) { return *slot; }
_ZN4absl12lts_2023012518container_internal15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEE7elementEPKS7_:
  775|    162|  static const value_type &element(const slot_type *slot) { return *slot; }
_ZN4absl12lts_2023012518container_internal15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEE9constructINSt3__19allocatorIS7_EEJS7_EEEvPT_PS7_DpOT0_:
  778|    430|  static void construct(Alloc *alloc, slot_type *slot, Args &&...args) {
  779|    430|    absl::allocator_traits<Alloc>::construct(*alloc, slot,
  780|    430|                                             std::forward<Args>(args)...);
  781|    430|  }
_ZN4absl12lts_2023012518container_internal15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEE7elementEPS7_:
  774|    430|  static value_type &element(slot_type *slot) { return *slot; }
_ZN4absl12lts_2023012518container_internal15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEE9constructINSt3__19allocatorIS7_EEEEvPT_PS7_SF_:
  784|     12|  static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
  785|     12|    absl::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other));
  786|     12|  }
_ZN4absl12lts_2023012518container_internal15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEE9constructINSt3__19allocatorIS7_EEJRKS7_EEEvPT_PS7_DpOT0_:
  778|     84|  static void construct(Alloc *alloc, slot_type *slot, Args &&...args) {
  779|     84|    absl::allocator_traits<Alloc>::construct(*alloc, slot,
  780|     84|                                             std::forward<Args>(args)...);
  781|     84|  }
_ZN4absl12lts_2023012518container_internal10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS6_13SymbolCompareENSt3__19allocatorIS7_EELi256ELb0EE3keyIS7_EERKT_SG_:
  809|     84|  static const V &key(const V &value) {
  810|     84|    return value;
  811|     84|  }

_ZN4absl12lts_2023012513flat_hash_mapIPKN6google8protobuf10DescriptorEPKNS3_7MessageENS0_18container_internal6HashEqIS6_vE4HashENSC_2EqENSt3__19allocatorINSF_4pairIKS6_S9_EEEEEC2Ev:
  159|      2|  flat_hash_map() {}

_ZN4absl12lts_2023012518container_internal17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEE7destroyINSt3__19allocatorIS8_EEEEvPT_PS8_:
  473|      8|  static void destroy(Allocator* alloc, slot_type* slot) {
  474|      8|    absl::allocator_traits<Allocator>::destroy(*alloc, slot);
  475|      8|  }
message.cc:_ZN4absl12lts_2023012513flat_hash_setIPKN6google8protobuf8internal15DescriptorTableENS3_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENS9_18DescriptorByNameEqENSt3__19allocatorIS7_EEEC2Ev:
  151|      2|  flat_hash_set() {}
_ZN4absl12lts_2023012518container_internal17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEE7elementEPS8_:
  477|     16|  static T& element(slot_type* slot) { return *slot; }
message.cc:_ZN4absl12lts_2023012518container_internal17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEE5applyINS1_12raw_hash_setIS9_NS4_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSD_18DescriptorByNameEqENSt3__19allocatorIS8_EEE19EmplaceDecomposableEJRKS8_EEEDTclsr4absl18container_internalE14DecomposeValueclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSN_DpOSO_:
  482|     12|  apply(F&& f, Args&&... args) {
  483|     12|    return absl::container_internal::DecomposeValue(
  484|     12|        std::forward<F>(f), std::forward<Args>(args)...);
  485|     12|  }
message.cc:_ZN4absl12lts_2023012518container_internal17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEE5applyINS1_12raw_hash_setIS9_NS4_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSD_18DescriptorByNameEqENSt3__19allocatorIS8_EEE11HashElementEJRS8_EEEDTclsr4absl18container_internalE14DecomposeValueclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSM_DpOSN_:
  482|      8|  apply(F&& f, Args&&... args) {
  483|      8|    return absl::container_internal::DecomposeValue(
  484|      8|        std::forward<F>(f), std::forward<Args>(args)...);
  485|      8|  }
_ZN4absl12lts_2023012518container_internal17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEE9constructINSt3__19allocatorIS8_EEJS8_EEEvPT_PS8_DpOT0_:
  467|      8|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  468|      8|    absl::allocator_traits<Allocator>::construct(*alloc, slot,
  469|      8|                                                 std::forward<Args>(args)...);
  470|      8|  }
_ZN4absl12lts_2023012518container_internal17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEE9constructINSt3__19allocatorIS8_EEJRKS8_EEEvPT_PS8_DpOT0_:
  467|     12|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  468|     12|    absl::allocator_traits<Allocator>::construct(*alloc, slot,
  469|     12|                                                 std::forward<Args>(args)...);
  470|     12|  }

_ZN4absl12lts_2023012518container_internal39btree_iterator_generation_info_disabledC2Ej:
 1061|    522|  explicit btree_iterator_generation_info_disabled(uint32_t) {}
_ZN4absl12lts_2023012518container_internal39btree_iterator_generation_info_disabled17update_generationEPKv:
 1062|    198|  void update_generation(const void *) {}
_ZNK4absl12lts_2023012518container_internal39btree_iterator_generation_info_disabled10generationEv:
 1063|     84|  uint32_t generation() const { return 0; }
_ZNK4absl12lts_2023012518container_internal39btree_iterator_generation_info_disabled23assert_valid_generationEPKv:
 1064|  1.24k|  void assert_valid_generation(const void *) const {}
_ZN4absl12lts_2023012518container_internal12SearchResultImLb0EEC2Em:
  478|    170|  explicit SearchResult(V v) : value(v) {}
_ZN4absl12lts_2023012518container_internal19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareENS6_9FileEntryEE15checked_compareC2ES7_:
  220|      2|    checked_compare(Compare comp) : Base(std::move(comp)) {}  // NOLINT
_ZN4absl12lts_2023012518container_internal20checked_compare_baseIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareELb1EEC2ES7_:
  167|      2|  explicit checked_compare_base(Compare c) : Compare(std::move(c)) {}
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEEC2ERKNS1_19key_compare_adapterIS9_S8_E15checked_compareERKSC_:
 1377|      2|      : root_(EmptyNode()), rightmost_(comp, alloc, EmptyNode()), size_(0) {}
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9EmptyNodeEv:
 1307|      4|  static node_type *EmptyNode() {
 1308|       |#ifdef _MSC_VER
 1309|       |    static EmptyNodeType *empty_node = new EmptyNodeType;
 1310|       |    // This assert fails on some other construction methods.
 1311|       |    assert(empty_node->parent == empty_node);
 1312|       |    return empty_node;
 1313|       |#else
 1314|      4|    static constexpr EmptyNodeType empty_node(
 1315|      4|        const_cast<EmptyNodeType *>(&empty_node));
 1316|      4|    return const_cast<EmptyNodeType *>(&empty_node);
 1317|      4|#endif
 1318|      4|  }
_ZN4absl12lts_2023012518container_internal19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS6_11SymbolEntryEE15checked_compareC2ES7_:
  220|      2|    checked_compare(Compare comp) : Base(std::move(comp)) {}  // NOLINT
_ZN4absl12lts_2023012518container_internal20checked_compare_baseIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareELb1EEC2ES7_:
  167|      2|  explicit checked_compare_base(Compare c) : Compare(std::move(c)) {}
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEEC2ERKNS1_19key_compare_adapterIS9_S8_E15checked_compareERKSC_:
 1377|      2|      : root_(EmptyNode()), rightmost_(comp, alloc, EmptyNode()), size_(0) {}
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9EmptyNodeEv:
 1307|      4|  static node_type *EmptyNode() {
 1308|       |#ifdef _MSC_VER
 1309|       |    static EmptyNodeType *empty_node = new EmptyNodeType;
 1310|       |    // This assert fails on some other construction methods.
 1311|       |    assert(empty_node->parent == empty_node);
 1312|       |    return empty_node;
 1313|       |#else
 1314|      4|    static constexpr EmptyNodeType empty_node(
 1315|      4|        const_cast<EmptyNodeType *>(&empty_node));
 1316|      4|    return const_cast<EmptyNodeType *>(&empty_node);
 1317|      4|#endif
 1318|      4|  }
_ZN4absl12lts_2023012518container_internal19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex16ExtensionCompareENS6_14ExtensionEntryEE15checked_compareC2ES7_:
  220|      2|    checked_compare(Compare comp) : Base(std::move(comp)) {}  // NOLINT
_ZN4absl12lts_2023012518container_internal20checked_compare_baseIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex16ExtensionCompareELb1EEC2ES7_:
  167|      2|  explicit checked_compare_base(Compare c) : Compare(std::move(c)) {}
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex14ExtensionEntryENS7_16ExtensionCompareENSt3__19allocatorIS8_EELi256ELb0EEEEC2ERKNS1_19key_compare_adapterIS9_S8_E15checked_compareERKSC_:
 1377|      2|      : root_(EmptyNode()), rightmost_(comp, alloc, EmptyNode()), size_(0) {}
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex14ExtensionEntryENS7_16ExtensionCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9EmptyNodeEv:
 1307|      4|  static node_type *EmptyNode() {
 1308|       |#ifdef _MSC_VER
 1309|       |    static EmptyNodeType *empty_node = new EmptyNodeType;
 1310|       |    // This assert fails on some other construction methods.
 1311|       |    assert(empty_node->parent == empty_node);
 1312|       |    return empty_node;
 1313|       |#else
 1314|      4|    static constexpr EmptyNodeType empty_node(
 1315|      4|        const_cast<EmptyNodeType *>(&empty_node));
 1316|      4|    return const_cast<EmptyNodeType *>(&empty_node);
 1317|      4|#endif
 1318|      4|  }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE5emptyEv:
 1557|     90|  bool empty() const { return size_ == 0; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE16clear_and_deleteEPSE_PSC_:
 1980|      6|void btree_node<P>::clear_and_delete(btree_node *node, allocator_type *alloc) {
 1981|      6|  if (node->is_leaf()) {
  ------------------
  |  Branch (1981:7): [True: 6, False: 0]
  ------------------
 1982|      6|    node->value_destroy_n(node->start(), node->count(), alloc);
 1983|      6|    deallocate(LeafSize(node->max_count()), node, alloc);
 1984|      6|    return;
 1985|      6|  }
 1986|      0|  if (node->count() == 0) {
  ------------------
  |  Branch (1986:7): [True: 0, False: 0]
  ------------------
 1987|      0|    deallocate(InternalSize(), node, alloc);
 1988|      0|    return;
 1989|      0|  }
 1990|       |
 1991|       |  // The parent of the root of the subtree we are deleting.
 1992|      0|  btree_node *delete_root_parent = node->parent();
 1993|       |
 1994|       |  // Navigate to the leftmost leaf under node, and then delete upwards.
 1995|      0|  while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (1995:10): [True: 0, False: 0]
  ------------------
 1996|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 1997|       |  // When generations are enabled, we delete the leftmost leaf last in case it's
 1998|       |  // the parent of the root and we need to check whether it's a leaf before we
 1999|       |  // can update the root's generation.
 2000|       |  // TODO(ezb): if we change btree_node::is_root to check a bool inside the node
 2001|       |  // instead of checking whether the parent is a leaf, we can remove this logic.
 2002|       |  btree_node *leftmost_leaf = node;
 2003|       |#endif
 2004|       |  // Use `size_type` because `pos` needs to be able to hold `kNodeSlots+1`,
 2005|       |  // which isn't guaranteed to be a valid `field_type`.
 2006|      0|  size_type pos = node->position();
 2007|      0|  btree_node *parent = node->parent();
 2008|      0|  for (;;) {
 2009|       |    // In each iteration of the next loop, we delete one leaf node and go right.
 2010|      0|    assert(pos <= parent->finish());
 2011|      0|    do {
 2012|      0|      node = parent->child(static_cast<field_type>(pos));
 2013|      0|      if (node->is_internal()) {
  ------------------
  |  Branch (2013:11): [True: 0, False: 0]
  ------------------
 2014|       |        // Navigate to the leftmost leaf under node.
 2015|      0|        while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (2015:16): [True: 0, False: 0]
  ------------------
 2016|      0|        pos = node->position();
 2017|      0|        parent = node->parent();
 2018|      0|      }
 2019|      0|      node->value_destroy_n(node->start(), node->count(), alloc);
 2020|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2021|       |      if (leftmost_leaf != node)
 2022|       |#endif
 2023|      0|        deallocate(LeafSize(node->max_count()), node, alloc);
 2024|      0|      ++pos;
 2025|      0|    } while (pos <= parent->finish());
  ------------------
  |  Branch (2025:14): [True: 0, False: 0]
  ------------------
 2026|       |
 2027|       |    // Once we've deleted all children of parent, delete parent and go up/right.
 2028|      0|    assert(pos > parent->finish());
 2029|      0|    do {
 2030|      0|      node = parent;
 2031|      0|      pos = node->position();
 2032|      0|      parent = node->parent();
 2033|      0|      node->value_destroy_n(node->start(), node->count(), alloc);
 2034|      0|      deallocate(InternalSize(), node, alloc);
 2035|      0|      if (parent == delete_root_parent) {
  ------------------
  |  Branch (2035:11): [True: 0, False: 0]
  ------------------
 2036|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2037|       |        deallocate(LeafSize(leftmost_leaf->max_count()), leftmost_leaf, alloc);
 2038|       |#endif
 2039|      0|        return;
 2040|      0|      }
 2041|      0|      ++pos;
 2042|      0|    } while (pos > parent->finish());
  ------------------
  |  Branch (2042:14): [True: 0, False: 0]
  ------------------
 2043|      0|  }
 2044|      0|}
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE7is_leafEv:
  686|    814|  bool is_leaf() const { return GetField<2>()[3] != kInternalNodeMaxCount; }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm2EEEPKNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  666|  2.65k|  inline const typename layout_type::template ElementType<N> *GetField() const {
  667|  2.65k|    assert(N < 4 || is_internal());
  668|  2.65k|    return InternalLayout().template Pointer<N>(
  669|  2.65k|        reinterpret_cast<const char *>(this));
  670|  2.65k|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE14InternalLayoutEv:
  642|  4.95k|  constexpr static layout_type InternalLayout() {
  643|  4.95k|    return layout_type(
  644|  4.95k|        /*parent*/ 1,
  645|  4.95k|        /*generation*/ params_type::kEnableGenerations ? 1 : 0,
  ------------------
  |  Branch (645:24): [Folded - Ignored]
  ------------------
  646|  4.95k|        /*position, start, finish, max_count*/ 4,
  647|  4.95k|        /*slots*/ kNodeSlots,
  648|  4.95k|        /*children*/ kNodeSlots + 1);
  649|  4.95k|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE15value_destroy_nEhhPSC_:
  960|      6|                       allocator_type *alloc) {
  961|      6|    next_generation();
  962|      6|    for (slot_type *s = slot(i), *end = slot(i + n); s != end; ++s) {
  ------------------
  |  Branch (962:54): [True: 0, False: 6]
  ------------------
  963|      0|      params_type::destroy(alloc, s);
  964|      0|      absl::container_internal::SanitizerPoisonObject(s);
  965|      0|    }
  966|      6|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE15next_generationEv:
  748|    312|  void next_generation() {
  749|    312|    if (params_type::kEnableGenerations) ++*get_root_generation();
  ------------------
  |  Branch (749:9): [Folded - Ignored]
  ------------------
  750|    312|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE4slotEm:
  673|    658|  slot_type *slot(size_type i) { return &GetField<3>()[i]; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm3EEEPNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  660|    658|  inline typename layout_type::template ElementType<N> *GetField() {
  661|       |    // We assert that we don't read from values that aren't there.
  662|    658|    assert(N < 4 || is_internal());
  663|    658|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  664|    658|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE5startEv:
  695|  1.13k|  field_type start() const {
  696|       |    // TODO(ezb): when floating storage is implemented, return GetField<2>()[1];
  697|  1.13k|    assert(GetField<2>()[1] == 0);
  698|  1.13k|    return 0;
  699|  1.13k|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE5countEv:
  705|    262|  field_type count() const {
  706|    262|    assert(finish() >= start());
  707|    262|    return finish() - start();
  708|    262|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10deallocateEmPSE_PSC_:
  939|      6|                         allocator_type *alloc) {
  940|      6|    absl::container_internal::SanitizerUnpoisonMemoryRegion(node, size);
  941|      6|    absl::container_internal::Deallocate<Alignment()>(alloc, node, size);
  942|      6|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8LeafSizeEm:
  650|     26|  constexpr static size_type LeafSize(const size_type slot_count = kNodeSlots) {
  651|     26|    return LeafLayout(slot_count).AllocSize();
  652|     26|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10LeafLayoutEm:
  634|     26|      const size_type slot_count = kNodeSlots) {
  635|     26|    return layout_type(
  636|     26|        /*parent*/ 1,
  637|     26|        /*generation*/ params_type::kEnableGenerations ? 1 : 0,
  ------------------
  |  Branch (637:24): [Folded - Ignored]
  ------------------
  638|     26|        /*position, start, finish, max_count*/ 4,
  639|     26|        /*slots*/ slot_count,
  640|     26|        /*children*/ 0);
  641|     26|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9max_countEv:
  709|     90|  field_type max_count() const {
  710|       |    // Internal nodes have max_count==kInternalNodeMaxCount.
  711|       |    // Leaf nodes have max_count in [1, kNodeSlots].
  712|     90|    const field_type max_count = GetField<2>()[3];
  713|     90|    return max_count == field_type{kInternalNodeMaxCount}
  ------------------
  |  Branch (713:12): [True: 0, False: 90]
  ------------------
  714|     90|               ? field_type{kNodeSlots}
  715|     90|               : max_count;
  716|     90|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE12InternalSizeEv:
  653|      2|  constexpr static size_type InternalSize() {
  654|      2|    return InternalLayout().AllocSize();
  655|      2|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE6parentEv:
  719|    356|  btree_node *parent() const { return *GetField<0>(); }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm0EEEPKNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  666|    356|  inline const typename layout_type::template ElementType<N> *GetField() const {
  667|    356|    assert(N < 4 || is_internal());
  668|    356|    return InternalLayout().template Pointer<N>(
  669|    356|        reinterpret_cast<const char *>(this));
  670|    356|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE11is_internalEv:
  689|    262|  bool is_internal() const { return !is_leaf(); }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8positionEv:
  692|    230|  field_type position() const { return GetField<2>()[0]; }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE5childEh:
  760|    174|  btree_node *child(field_type i) const { return GetField<4>()[i]; }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm4EEEPKNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  666|    174|  inline const typename layout_type::template ElementType<N> *GetField() const {
  667|    174|    assert(N < 4 || is_internal());
  668|    174|    return InternalLayout().template Pointer<N>(
  669|    174|        reinterpret_cast<const char *>(this));
  670|    174|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE6finishEv:
  702|  1.52k|  field_type finish() const { return GetField<2>()[2]; }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE4rootEv:
 1633|    130|  node_type *root() { return root_; }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE17mutable_allocatorEv:
 1650|    144|  allocator_type *mutable_allocator() noexcept {
 1651|    144|    return &rightmost_.template get<1>();
 1652|    144|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE17mutable_rightmostEv:
 1638|     12|  node_type *&mutable_rightmost() noexcept {
 1639|     12|    return rightmost_.template get<2>();
 1640|     12|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE12mutable_rootEv:
 1635|     10|  node_type *&mutable_root() noexcept { return root_; }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE5emptyEv:
 1557|     12|  bool empty() const { return size_ == 0; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE16clear_and_deleteEPSE_PSC_:
 1980|      6|void btree_node<P>::clear_and_delete(btree_node *node, allocator_type *alloc) {
 1981|      6|  if (node->is_leaf()) {
  ------------------
  |  Branch (1981:7): [True: 6, False: 0]
  ------------------
 1982|      6|    node->value_destroy_n(node->start(), node->count(), alloc);
 1983|      6|    deallocate(LeafSize(node->max_count()), node, alloc);
 1984|      6|    return;
 1985|      6|  }
 1986|      0|  if (node->count() == 0) {
  ------------------
  |  Branch (1986:7): [True: 0, False: 0]
  ------------------
 1987|      0|    deallocate(InternalSize(), node, alloc);
 1988|      0|    return;
 1989|      0|  }
 1990|       |
 1991|       |  // The parent of the root of the subtree we are deleting.
 1992|      0|  btree_node *delete_root_parent = node->parent();
 1993|       |
 1994|       |  // Navigate to the leftmost leaf under node, and then delete upwards.
 1995|      0|  while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (1995:10): [True: 0, False: 0]
  ------------------
 1996|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 1997|       |  // When generations are enabled, we delete the leftmost leaf last in case it's
 1998|       |  // the parent of the root and we need to check whether it's a leaf before we
 1999|       |  // can update the root's generation.
 2000|       |  // TODO(ezb): if we change btree_node::is_root to check a bool inside the node
 2001|       |  // instead of checking whether the parent is a leaf, we can remove this logic.
 2002|       |  btree_node *leftmost_leaf = node;
 2003|       |#endif
 2004|       |  // Use `size_type` because `pos` needs to be able to hold `kNodeSlots+1`,
 2005|       |  // which isn't guaranteed to be a valid `field_type`.
 2006|      0|  size_type pos = node->position();
 2007|      0|  btree_node *parent = node->parent();
 2008|      0|  for (;;) {
 2009|       |    // In each iteration of the next loop, we delete one leaf node and go right.
 2010|      0|    assert(pos <= parent->finish());
 2011|      0|    do {
 2012|      0|      node = parent->child(static_cast<field_type>(pos));
 2013|      0|      if (node->is_internal()) {
  ------------------
  |  Branch (2013:11): [True: 0, False: 0]
  ------------------
 2014|       |        // Navigate to the leftmost leaf under node.
 2015|      0|        while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (2015:16): [True: 0, False: 0]
  ------------------
 2016|      0|        pos = node->position();
 2017|      0|        parent = node->parent();
 2018|      0|      }
 2019|      0|      node->value_destroy_n(node->start(), node->count(), alloc);
 2020|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2021|       |      if (leftmost_leaf != node)
 2022|       |#endif
 2023|      0|        deallocate(LeafSize(node->max_count()), node, alloc);
 2024|      0|      ++pos;
 2025|      0|    } while (pos <= parent->finish());
  ------------------
  |  Branch (2025:14): [True: 0, False: 0]
  ------------------
 2026|       |
 2027|       |    // Once we've deleted all children of parent, delete parent and go up/right.
 2028|      0|    assert(pos > parent->finish());
 2029|      0|    do {
 2030|      0|      node = parent;
 2031|      0|      pos = node->position();
 2032|      0|      parent = node->parent();
 2033|      0|      node->value_destroy_n(node->start(), node->count(), alloc);
 2034|      0|      deallocate(InternalSize(), node, alloc);
 2035|      0|      if (parent == delete_root_parent) {
  ------------------
  |  Branch (2035:11): [True: 0, False: 0]
  ------------------
 2036|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2037|       |        deallocate(LeafSize(leftmost_leaf->max_count()), leftmost_leaf, alloc);
 2038|       |#endif
 2039|      0|        return;
 2040|      0|      }
 2041|      0|      ++pos;
 2042|      0|    } while (pos > parent->finish());
  ------------------
  |  Branch (2042:14): [True: 0, False: 0]
  ------------------
 2043|      0|  }
 2044|      0|}
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE7is_leafEv:
  686|     48|  bool is_leaf() const { return GetField<2>()[3] != kInternalNodeMaxCount; }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm2EEEPKNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  666|    156|  inline const typename layout_type::template ElementType<N> *GetField() const {
  667|    156|    assert(N < 4 || is_internal());
  668|    156|    return InternalLayout().template Pointer<N>(
  669|    156|        reinterpret_cast<const char *>(this));
  670|    156|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE14InternalLayoutEv:
  642|    320|  constexpr static layout_type InternalLayout() {
  643|    320|    return layout_type(
  644|    320|        /*parent*/ 1,
  645|    320|        /*generation*/ params_type::kEnableGenerations ? 1 : 0,
  ------------------
  |  Branch (645:24): [Folded - Ignored]
  ------------------
  646|    320|        /*position, start, finish, max_count*/ 4,
  647|    320|        /*slots*/ kNodeSlots,
  648|    320|        /*children*/ kNodeSlots + 1);
  649|    320|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE15value_destroy_nEhhPSC_:
  960|      6|                       allocator_type *alloc) {
  961|      6|    next_generation();
  962|      6|    for (slot_type *s = slot(i), *end = slot(i + n); s != end; ++s) {
  ------------------
  |  Branch (962:54): [True: 0, False: 6]
  ------------------
  963|      0|      params_type::destroy(alloc, s);
  964|      0|      absl::container_internal::SanitizerPoisonObject(s);
  965|      0|    }
  966|      6|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE15next_generationEv:
  748|     30|  void next_generation() {
  749|     30|    if (params_type::kEnableGenerations) ++*get_root_generation();
  ------------------
  |  Branch (749:9): [Folded - Ignored]
  ------------------
  750|     30|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE4slotEm:
  673|     68|  slot_type *slot(size_type i) { return &GetField<3>()[i]; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm3EEEPNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  660|     68|  inline typename layout_type::template ElementType<N> *GetField() {
  661|       |    // We assert that we don't read from values that aren't there.
  662|     68|    assert(N < 4 || is_internal());
  663|     68|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  664|     68|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE5startEv:
  695|     80|  field_type start() const {
  696|       |    // TODO(ezb): when floating storage is implemented, return GetField<2>()[1];
  697|     80|    assert(GetField<2>()[1] == 0);
  698|     80|    return 0;
  699|     80|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE5countEv:
  705|     24|  field_type count() const {
  706|     24|    assert(finish() >= start());
  707|     24|    return finish() - start();
  708|     24|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10deallocateEmPSE_PSC_:
  939|      6|                         allocator_type *alloc) {
  940|      6|    absl::container_internal::SanitizerUnpoisonMemoryRegion(node, size);
  941|      6|    absl::container_internal::Deallocate<Alignment()>(alloc, node, size);
  942|      6|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8LeafSizeEm:
  650|     14|  constexpr static size_type LeafSize(const size_type slot_count = kNodeSlots) {
  651|     14|    return LeafLayout(slot_count).AllocSize();
  652|     14|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10LeafLayoutEm:
  634|     14|      const size_type slot_count = kNodeSlots) {
  635|     14|    return layout_type(
  636|     14|        /*parent*/ 1,
  637|     14|        /*generation*/ params_type::kEnableGenerations ? 1 : 0,
  ------------------
  |  Branch (637:24): [Folded - Ignored]
  ------------------
  638|     14|        /*position, start, finish, max_count*/ 4,
  639|     14|        /*slots*/ slot_count,
  640|     14|        /*children*/ 0);
  641|     14|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9max_countEv:
  709|     18|  field_type max_count() const {
  710|       |    // Internal nodes have max_count==kInternalNodeMaxCount.
  711|       |    // Leaf nodes have max_count in [1, kNodeSlots].
  712|     18|    const field_type max_count = GetField<2>()[3];
  713|     18|    return max_count == field_type{kInternalNodeMaxCount}
  ------------------
  |  Branch (713:12): [True: 0, False: 18]
  ------------------
  714|     18|               ? field_type{kNodeSlots}
  715|     18|               : max_count;
  716|     18|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE6parentEv:
  719|      6|  btree_node *parent() const { return *GetField<0>(); }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm0EEEPKNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  666|      6|  inline const typename layout_type::template ElementType<N> *GetField() const {
  667|      6|    assert(N < 4 || is_internal());
  668|      6|    return InternalLayout().template Pointer<N>(
  669|      6|        reinterpret_cast<const char *>(this));
  670|      6|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE11is_internalEv:
  689|     24|  bool is_internal() const { return !is_leaf(); }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8positionEv:
  692|      6|  field_type position() const { return GetField<2>()[0]; }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE6finishEv:
  702|     84|  field_type finish() const { return GetField<2>()[2]; }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE4rootEv:
 1633|      6|  node_type *root() { return root_; }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE17mutable_allocatorEv:
 1650|     20|  allocator_type *mutable_allocator() noexcept {
 1651|     20|    return &rightmost_.template get<1>();
 1652|     20|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE17mutable_rightmostEv:
 1638|      8|  node_type *&mutable_rightmost() noexcept {
 1639|      8|    return rightmost_.template get<2>();
 1640|      8|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE12mutable_rootEv:
 1635|      8|  node_type *&mutable_root() noexcept { return root_; }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13insert_uniqueIS8_JS8_EEENSA_4pairINS1_14btree_iteratorINS1_10btree_nodeISD_EERS8_PS8_EEbEERKT_DpOT0_:
 2250|     12|    -> std::pair<iterator, bool> {
 2251|     12|  if (empty()) {
  ------------------
  |  Branch (2251:7): [True: 2, False: 10]
  ------------------
 2252|      2|    mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
 2253|      2|  }
 2254|       |
 2255|     12|  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
 2256|     12|  iterator iter = res.value;
 2257|       |
 2258|     12|  if (res.HasMatch()) {
  ------------------
  |  Branch (2258:7): [Folded - Ignored]
  ------------------
 2259|      0|    if (res.IsEq()) {
  ------------------
  |  Branch (2259:9): [Folded - Ignored]
  ------------------
 2260|       |      // The key already exists in the tree, do nothing.
 2261|      0|      return {iter, false};
 2262|      0|    }
 2263|     12|  } else {
 2264|     12|    iterator last = internal_last(iter);
 2265|     12|    if (last.node_ && !compare_keys(key, last.key())) {
  ------------------
  |  Branch (2265:9): [True: 6, False: 6]
  |  Branch (2265:23): [True: 0, False: 6]
  ------------------
 2266|       |      // The key already exists in the tree, do nothing.
 2267|      0|      return {last, false};
 2268|      0|    }
 2269|     12|  }
 2270|     12|  return {internal_emplace(iter, std::forward<Args>(args)...), true};
 2271|     12|}
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE18new_leaf_root_nodeEh:
 1676|      8|  node_type *new_leaf_root_node(field_type max_count) {
 1677|      8|    node_type *n = allocate(node_type::LeafSize(max_count));
 1678|      8|    n->init_leaf(max_count, /*parent=*/n);
 1679|      8|    return n;
 1680|      8|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8allocateEm:
 1659|      8|  node_type *allocate(size_type size) {
 1660|      8|    return reinterpret_cast<node_type *>(
 1661|      8|        absl::container_internal::Allocate<node_type::Alignment()>(
 1662|      8|            mutable_allocator(), size));
 1663|      8|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9init_leafEhPSE_:
  919|      8|  void init_leaf(field_type max_count, btree_node *parent) {
  920|      8|    set_generation(0);
  921|      8|    set_parent(parent);
  922|      8|    set_position(0);
  923|      8|    set_start(0);
  924|      8|    set_finish(0);
  925|      8|    set_max_count(max_count);
  926|      8|    absl::container_internal::SanitizerPoisonMemoryRegion(
  927|      8|        start_slot(), max_count * sizeof(slot_type));
  928|      8|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE14set_generationEj:
  744|     14|  void set_generation(uint32_t generation) {
  745|     14|    if (params_type::kEnableGenerations) GetField<1>()[0] = generation;
  ------------------
  |  Branch (745:9): [Folded - Ignored]
  ------------------
  746|     14|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10set_parentEPSE_:
  671|      8|  void set_parent(btree_node *p) { *GetField<0>() = p; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm0EEEPNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  660|      8|  inline typename layout_type::template ElementType<N> *GetField() {
  661|       |    // We assert that we don't read from values that aren't there.
  662|      8|    assert(N < 4 || is_internal());
  663|      8|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  664|      8|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE12set_positionEh:
  677|      8|  void set_position(field_type v) { GetField<2>()[0] = v; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm2EEEPNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  660|     56|  inline typename layout_type::template ElementType<N> *GetField() {
  661|       |    // We assert that we don't read from values that aren't there.
  662|     56|    assert(N < 4 || is_internal());
  663|     56|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  664|     56|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9set_startEh:
  678|      8|  void set_start(field_type v) { GetField<2>()[1] = v; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10set_finishEh:
  679|     32|  void set_finish(field_type v) { GetField<2>()[2] = v; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13set_max_countEh:
  681|      8|  void set_max_count(field_type v) { GetField<2>()[3] = v; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10start_slotEv:
  674|      8|  slot_type *start_slot() { return slot(start()); }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE15internal_locateIS8_EENS1_12SearchResultINS1_14btree_iteratorINS1_10btree_nodeISD_EERS8_PS8_EELb0EEERKT_:
 2827|     12|    -> SearchResult<iterator, is_key_compare_to::value> {
 2828|     12|  iterator iter(const_cast<node_type *>(root()));
 2829|     12|  for (;;) {
 2830|     12|    SearchResult<size_type, is_key_compare_to::value> res =
 2831|     12|        iter.node_->lower_bound(key, key_comp());
 2832|     12|    iter.position_ = static_cast<int>(res.value);
 2833|     12|    if (res.IsEq()) {
  ------------------
  |  Branch (2833:9): [Folded - Ignored]
  ------------------
 2834|      0|      return {iter, MatchKind::kEq};
 2835|      0|    }
 2836|       |    // Note: in the non-key-compare-to case, we don't need to walk all the way
 2837|       |    // down the tree if the keys are equal, but determining equality would
 2838|       |    // require doing an extra comparison on each node on the way down, and we
 2839|       |    // will need to go all the way to the leaf node in the expected case.
 2840|     12|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (2840:9): [True: 12, False: 0]
  ------------------
 2841|     12|      break;
 2842|     12|    }
 2843|      0|    iter.node_ = iter.node_->child(static_cast<field_type>(iter.position_));
 2844|      0|  }
 2845|       |  // Note: in the non-key-compare-to case, the key may actually be equivalent
 2846|       |  // here (and the MatchKind::kNe is ignored).
 2847|     12|  return {iter, MatchKind::kNe};
 2848|     12|}
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE4rootEv:
 1634|     12|  const node_type *root() const { return root_; }
_ZN4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS8_11FileCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_EC2EPSF_:
 1104|     12|  explicit btree_iterator(Node *n) : btree_iterator(n, n->start()) {}
_ZN4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS8_11FileCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_EC2EPSF_i:
 1109|     12|        position_(p) {}
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10generationEv:
  739|     18|  uint32_t generation() const {
  740|     18|    return params_type::kEnableGenerations ? *get_root_generation() : 0;
  ------------------
  |  Branch (740:12): [Folded - Ignored]
  ------------------
  741|     18|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE11lower_boundIS8_EENS1_12SearchResultImLb0EEERKT_RKNS1_19key_compare_adapterIS9_S8_E15checked_compareE:
  779|     12|      const K &k, const key_compare &comp) const {
  780|     12|    return use_linear_search::value ? linear_search(k, comp)
  ------------------
  |  Branch (780:12): [Folded - Ignored]
  ------------------
  781|     12|                                    : binary_search(k, comp);
  782|     12|  }
_ZNK4absl12lts_2023012518container_internal19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareENS6_9FileEntryEE15checked_compareclIS8_S8_Li0EEEbRKT_RKT0_:
  229|     26|    bool operator()(const T &lhs, const U &rhs) const {
  230|       |      // NOTE: if any of these assertions fail, then the comparator does not
  231|       |      // establish a strict-weak-ordering (see
  232|       |      // https://en.cppreference.com/w/cpp/named_req/Compare).
  233|     26|      assert(is_self_equivalent(lhs));
  234|     26|      assert(is_self_equivalent(rhs));
  235|     26|      const bool lhs_comp_rhs = comp()(lhs, rhs);
  236|     26|      assert(!lhs_comp_rhs || !comp()(rhs, lhs));
  237|     26|      return lhs_comp_rhs;
  238|     26|    }
_ZNK4absl12lts_2023012518container_internal20checked_compare_baseIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareELb1EE4compEv:
  168|     26|  const Compare &comp() const { return *this; }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE3keyEm:
  753|     26|  const key_type &key(size_type i) const { return params_type::key(slot(i)); }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE4slotEm:
  676|     26|  const slot_type *slot(size_type i) const { return &GetField<3>()[i]; }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm3EEEPKNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  666|     26|  inline const typename layout_type::template ElementType<N> *GetField() const {
  667|     26|    assert(N < 4 || is_internal());
  668|     26|    return InternalLayout().template Pointer<N>(
  669|     26|        reinterpret_cast<const char *>(this));
  670|     26|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13binary_searchIS8_NS1_19key_compare_adapterIS9_S8_E15checked_compareEEENS1_12SearchResultImXsr23btree_is_key_compare_toIT0_S8_EE5valueEEERKT_RKSK_:
  800|     12|  binary_search(const K &k, const Compare &comp) const {
  801|     12|    return binary_search_impl(k, start(), finish(), comp,
  802|     12|                              btree_is_key_compare_to<Compare, key_type>());
  803|     12|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE18binary_search_implIS8_NS1_19key_compare_adapterIS9_S8_E15checked_compareEEENS1_12SearchResultImLb0EEERKT_mmRKT0_NSA_17integral_constantIbLb0EEE:
  843|     12|      std::false_type /* IsCompareTo */) const {
  844|     32|    while (s != e) {
  ------------------
  |  Branch (844:12): [True: 20, False: 12]
  ------------------
  845|     20|      const size_type mid = (s + e) >> 1;
  846|     20|      if (comp(key(mid), k)) {
  ------------------
  |  Branch (846:11): [True: 12, False: 8]
  ------------------
  847|     12|        s = mid + 1;
  848|     12|      } else {
  849|      8|        e = mid;
  850|      8|      }
  851|     20|    }
  852|     12|    return SearchResult<size_type, false>{s};
  853|     12|  }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8key_compEv:
 1539|     30|  const key_compare &key_comp() const noexcept {
 1540|     30|    return rightmost_.template get<0>();
 1541|     30|  }
_ZN4absl12lts_2023012518container_internal12SearchResultINS1_14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS9_11FileCompareENSt3__19allocatorISA_EELi256ELb0EEEEERSA_PSA_EELb0EEC2ESJ_NS1_9MatchKindE:
  479|     12|  SearchResult(V v, MatchKind /*match*/) : value(v) {}
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13internal_lastINS1_14btree_iteratorINS1_10btree_nodeISD_EERS8_PS8_EEEET_SM_:
 2769|     12|inline IterType btree<P>::internal_last(IterType iter) {
 2770|     12|  assert(iter.node_ != nullptr);
 2771|     12|  while (iter.position_ == iter.node_->finish()) {
  ------------------
  |  Branch (2771:10): [True: 6, False: 6]
  ------------------
 2772|      6|    iter.position_ = iter.node_->position();
 2773|      6|    iter.node_ = iter.node_->parent();
 2774|      6|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (2774:9): [True: 6, False: 0]
  ------------------
 2775|      6|      iter.node_ = nullptr;
 2776|      6|      break;
 2777|      6|    }
 2778|      6|  }
 2779|     12|  iter.update_generation();
 2780|     12|  return iter;
 2781|     12|}
_ZN4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS8_11FileCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_E17update_generationEv:
 1266|     24|  void update_generation() {
 1267|     24|    btree_iterator_generation_info::update_generation(node_);
 1268|     24|  }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE12compare_keysIS8_S8_EEbRKT_RKT0_:
 1543|      6|  bool compare_keys(const K1 &a, const K2 &b) const {
 1544|      6|    return compare_internal::compare_result_as_less_than(key_comp()(a, b));
 1545|      6|  }
_ZNK4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS8_11FileCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_E3keyEv:
 1259|      6|  const key_type &key() const {
 1260|      6|    return node_->key(static_cast<size_type>(position_));
 1261|      6|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE16internal_emplaceIJS8_EEENS1_14btree_iteratorINS1_10btree_nodeISD_EERS8_PS8_EESL_DpOT_:
 2786|     12|    -> iterator {
 2787|     12|  if (iter.node_->is_internal()) {
  ------------------
  |  Branch (2787:7): [True: 0, False: 12]
  ------------------
 2788|       |    // We can't insert on an internal node. Instead, we'll insert after the
 2789|       |    // previous value which is guaranteed to be on a leaf node.
 2790|      0|    --iter;
 2791|      0|    ++iter.position_;
 2792|      0|  }
 2793|     12|  const field_type max_count = iter.node_->max_count();
 2794|     12|  allocator_type *alloc = mutable_allocator();
 2795|     12|  if (iter.node_->count() == max_count) {
  ------------------
  |  Branch (2795:7): [True: 6, False: 6]
  ------------------
 2796|       |    // Make room in the leaf for the new item.
 2797|      6|    if (max_count < kNodeSlots) {
  ------------------
  |  Branch (2797:9): [True: 6, False: 0]
  ------------------
 2798|       |      // Insertion into the root where the root is smaller than the full node
 2799|       |      // size. Simply grow the size of the root node.
 2800|      6|      assert(iter.node_ == root());
 2801|      6|      iter.node_ = new_leaf_root_node(static_cast<field_type>(
 2802|      6|          (std::min)(static_cast<int>(kNodeSlots), 2 * max_count)));
 2803|       |      // Transfer the values from the old root to the new root.
 2804|      6|      node_type *old_root = root();
 2805|      6|      node_type *new_root = iter.node_;
 2806|      6|      new_root->transfer_n(old_root->count(), new_root->start(),
 2807|      6|                           old_root->start(), old_root, alloc);
 2808|      6|      new_root->set_finish(old_root->finish());
 2809|      6|      old_root->set_finish(old_root->start());
 2810|      6|      new_root->set_generation(old_root->generation());
 2811|      6|      node_type::clear_and_delete(old_root, alloc);
 2812|      6|      mutable_root() = mutable_rightmost() = new_root;
 2813|      6|    } else {
 2814|      0|      rebalance_or_split(&iter);
 2815|      0|    }
 2816|      6|  }
 2817|     12|  iter.node_->emplace_value(static_cast<field_type>(iter.position_), alloc,
 2818|     12|                            std::forward<Args>(args)...);
 2819|     12|  ++size_;
 2820|     12|  iter.update_generation();
 2821|     12|  return iter;
 2822|     12|}
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10transfer_nEmmmPSE_PSC_:
  985|      6|                  allocator_type *alloc) {
  986|      6|    next_generation();
  987|      6|    for (slot_type *src = src_node->slot(src_i), *end = src + n,
  988|      6|                   *dest = slot(dest_i);
  989|     20|         src != end; ++src, ++dest) {
  ------------------
  |  Branch (989:10): [True: 14, False: 6]
  ------------------
  990|     14|      transfer(dest, src, alloc);
  991|     14|    }
  992|      6|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8transferEPS8_SF_PSC_:
  968|     26|  static void transfer(slot_type *dest, slot_type *src, allocator_type *alloc) {
  969|     26|    absl::container_internal::SanitizerUnpoisonObject(dest);
  970|     26|    params_type::transfer(alloc, dest, src);
  971|     26|    absl::container_internal::SanitizerPoisonObject(src);
  972|     26|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE19transfer_n_backwardEmmmPSE_PSC_:
  998|      6|                           allocator_type *alloc) {
  999|      6|    next_generation();
 1000|      6|    for (slot_type *src = src_node->slot(src_i + n), *end = src - n,
 1001|      6|                   *dest = slot(dest_i + n);
 1002|     18|         src != end; --src, --dest) {
  ------------------
  |  Branch (1002:10): [True: 12, False: 6]
  ------------------
 1003|       |      // If we modified the loop index calculations above to avoid the -1s here,
 1004|       |      // it would result in UB in the computation of `end` (and possibly `src`
 1005|       |      // as well, if n == 0), since slot() is effectively an array index and it
 1006|       |      // is UB to compute the address of any out-of-bounds array element except
 1007|       |      // for one-past-the-end.
 1008|     12|      transfer(dest - 1, src - 1, alloc);
 1009|     12|    }
 1010|      6|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13emplace_valueIJS8_EEEvhPSC_DpOT_:
 1781|     12|                                         Args &&...args) {
 1782|     12|  assert(i >= start());
 1783|     12|  assert(i <= finish());
 1784|       |  // Shift old values to create space for new value and then construct it in
 1785|       |  // place.
 1786|     12|  if (i < finish()) {
  ------------------
  |  Branch (1786:7): [True: 6, False: 6]
  ------------------
 1787|      6|    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
 1788|      6|                        alloc);
 1789|      6|  }
 1790|     12|  value_init(static_cast<field_type>(i), alloc, std::forward<Args>(args)...);
 1791|     12|  set_finish(finish() + 1);
 1792|       |
 1793|     12|  if (is_internal() && finish() > i + 1) {
  ------------------
  |  Branch (1793:7): [True: 0, False: 12]
  |  Branch (1793:24): [True: 0, False: 0]
  ------------------
 1794|      0|    for (field_type j = finish(); j > i + 1; --j) {
  ------------------
  |  Branch (1794:35): [True: 0, False: 0]
  ------------------
 1795|      0|      set_child(j, child(j - 1));
 1796|      0|    }
 1797|      0|    clear_child(i + 1);
 1798|      0|  }
 1799|     12|}
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS7_11FileCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10value_initIJS8_EEEvhPSC_DpOT_:
  949|     12|  void value_init(const field_type i, allocator_type *alloc, Args &&...args) {
  950|     12|    next_generation();
  951|     12|    absl::container_internal::SanitizerUnpoisonObject(slot(i));
  952|     12|    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
  953|     12|  }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE11upper_boundIS8_EENS1_14btree_iteratorIKNS1_10btree_nodeISD_EERKS8_PSK_EERKT_:
 1447|     84|  const_iterator upper_bound(const K &key) const {
 1448|     84|    return internal_end(internal_upper_bound(key));
 1449|     84|  }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE12internal_endENS1_14btree_iteratorIKNS1_10btree_nodeISD_EERKS8_PSJ_EE:
 1704|     84|  const_iterator internal_end(const_iterator iter) const {
 1705|     84|    return iter.node_ != nullptr ? iter : end();
  ------------------
  |  Branch (1705:12): [True: 80, False: 4]
  ------------------
 1706|     84|  }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE3endEv:
 1414|      4|  const_iterator end() const {
 1415|      4|    return const_iterator(rightmost(), rightmost()->finish());
 1416|      4|  }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9rightmostEv:
 1637|      8|  const node_type *rightmost() const { return rightmost_.template get<2>(); }
_ZN4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_EC2EPSG_i:
 1109|     88|        position_(p) {}
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10generationEv:
  739|    434|  uint32_t generation() const {
  740|    434|    return params_type::kEnableGenerations ? *get_root_generation() : 0;
  ------------------
  |  Branch (740:12): [Folded - Ignored]
  ------------------
  741|    434|  }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE20internal_upper_boundIS8_EENS1_14btree_iteratorINS1_10btree_nodeISD_EERS8_PS8_EERKT_:
 2877|     84|auto btree<P>::internal_upper_bound(const K &key) const -> iterator {
 2878|     84|  iterator iter(const_cast<node_type *>(root()));
 2879|    152|  for (;;) {
 2880|    152|    iter.position_ = static_cast<int>(iter.node_->upper_bound(key, key_comp()));
 2881|    152|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (2881:9): [True: 84, False: 68]
  ------------------
 2882|     84|      break;
 2883|     84|    }
 2884|     68|    iter.node_ = iter.node_->child(static_cast<field_type>(iter.position_));
 2885|     68|  }
 2886|     84|  return internal_last(iter);
 2887|     84|}
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE4rootEv:
 1634|    174|  const node_type *root() const { return root_; }
_ZN4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_EC2EPSF_:
 1104|    172|  explicit btree_iterator(Node *n) : btree_iterator(n, n->start()) {}
_ZN4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_EC2EPSF_i:
 1109|    338|        position_(p) {}
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE11upper_boundIS8_EEmRKT_RKNS1_19key_compare_adapterIS9_S8_E15checked_compareE:
  785|    152|  size_type upper_bound(const K &k, const key_compare &comp) const {
  786|    152|    auto upper_compare = upper_bound_adapter<key_compare>(comp);
  787|    152|    return use_linear_search::value ? linear_search(k, upper_compare).value
  ------------------
  |  Branch (787:12): [Folded - Ignored]
  ------------------
  788|    152|                                    : binary_search(k, upper_compare).value;
  789|    152|  }
_ZN4absl12lts_2023012518container_internal19upper_bound_adapterINS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS7_11SymbolEntryEE15checked_compareEEC2ERKSB_:
  450|    152|  explicit upper_bound_adapter(const Compare &c) : comp(c) {}
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13binary_searchIS8_NS1_19upper_bound_adapterINS1_19key_compare_adapterIS9_S8_E15checked_compareEEEEENS1_12SearchResultImXsr23btree_is_key_compare_toIT0_S8_EE5valueEEERKT_RKSM_:
  800|    152|  binary_search(const K &k, const Compare &comp) const {
  801|    152|    return binary_search_impl(k, start(), finish(), comp,
  802|    152|                              btree_is_key_compare_to<Compare, key_type>());
  803|    152|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE18binary_search_implIS8_NS1_19upper_bound_adapterINS1_19key_compare_adapterIS9_S8_E15checked_compareEEEEENS1_12SearchResultImLb0EEERKT_mmRKT0_NSA_17integral_constantIbLb0EEE:
  843|    152|      std::false_type /* IsCompareTo */) const {
  844|    502|    while (s != e) {
  ------------------
  |  Branch (844:12): [True: 350, False: 152]
  ------------------
  845|    350|      const size_type mid = (s + e) >> 1;
  846|    350|      if (comp(key(mid), k)) {
  ------------------
  |  Branch (846:11): [True: 158, False: 192]
  ------------------
  847|    158|        s = mid + 1;
  848|    192|      } else {
  849|    192|        e = mid;
  850|    192|      }
  851|    350|    }
  852|    152|    return SearchResult<size_type, false>{s};
  853|    152|  }
_ZNK4absl12lts_2023012518container_internal19upper_bound_adapterINS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS7_11SymbolEntryEE15checked_compareEEclIS9_S9_EEbRKT_RKT0_:
  452|    350|  bool operator()(const K1 &a, const K2 &b) const {
  453|       |    // Returns true when a is not greater than b.
  454|    350|    return !compare_internal::compare_result_as_less_than(comp(b, a));
  455|    350|  }
_ZNK4absl12lts_2023012518container_internal19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS6_11SymbolEntryEE15checked_compareclIS8_S8_Li0EEEbRKT_RKT0_:
  229|    526|    bool operator()(const T &lhs, const U &rhs) const {
  230|       |      // NOTE: if any of these assertions fail, then the comparator does not
  231|       |      // establish a strict-weak-ordering (see
  232|       |      // https://en.cppreference.com/w/cpp/named_req/Compare).
  233|    526|      assert(is_self_equivalent(lhs));
  234|    526|      assert(is_self_equivalent(rhs));
  235|    526|      const bool lhs_comp_rhs = comp()(lhs, rhs);
  236|    526|      assert(!lhs_comp_rhs || !comp()(rhs, lhs));
  237|    526|      return lhs_comp_rhs;
  238|    526|    }
_ZNK4absl12lts_2023012518container_internal20checked_compare_baseIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareELb1EE4compEv:
  168|    526|  const Compare &comp() const { return *this; }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE3keyEm:
  753|    526|  const key_type &key(size_type i) const { return params_type::key(slot(i)); }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE4slotEm:
  676|    688|  const slot_type *slot(size_type i) const { return &GetField<3>()[i]; }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm3EEEPKNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  666|    688|  inline const typename layout_type::template ElementType<N> *GetField() const {
  667|    688|    assert(N < 4 || is_internal());
  668|    688|    return InternalLayout().template Pointer<N>(
  669|    688|        reinterpret_cast<const char *>(this));
  670|    688|  }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8key_compEv:
 1539|    408|  const key_compare &key_comp() const noexcept {
 1540|    408|    return rightmost_.template get<0>();
 1541|    408|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13internal_lastINS1_14btree_iteratorINS1_10btree_nodeISD_EERS8_PS8_EEEET_SM_:
 2769|     90|inline IterType btree<P>::internal_last(IterType iter) {
 2770|     90|  assert(iter.node_ != nullptr);
 2771|    102|  while (iter.position_ == iter.node_->finish()) {
  ------------------
  |  Branch (2771:10): [True: 18, False: 84]
  ------------------
 2772|     18|    iter.position_ = iter.node_->position();
 2773|     18|    iter.node_ = iter.node_->parent();
 2774|     18|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (2774:9): [True: 6, False: 12]
  ------------------
 2775|      6|      iter.node_ = nullptr;
 2776|      6|      break;
 2777|      6|    }
 2778|     18|  }
 2779|     90|  iter.update_generation();
 2780|     90|  return iter;
 2781|     90|}
_ZN4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_E17update_generationEv:
 1266|    174|  void update_generation() {
 1267|    174|    btree_iterator_generation_info::update_generation(node_);
 1268|    174|  }
_ZN4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_EC2ISF_RS9_PS9_Li0EEENS2_IT_T0_T1_EE:
 1122|    414|        position_(other.position_) {}
_ZNK4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_EneERKSK_:
 1133|     84|  bool operator!=(const const_iterator &other) const {
 1134|     84|    return !Equals(other);
 1135|     84|  }
_ZNK4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_E6EqualsESK_:
 1210|    250|  bool Equals(const const_iterator other) const {
 1211|    250|    ABSL_HARDENING_ASSERT(((node_ == nullptr && other.node_ == nullptr) ||
  ------------------
  |  |  128|    250|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|    250|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1212|    250|                           (node_ != nullptr && other.node_ != nullptr)) &&
 1213|    250|                          "Comparing default-constructed iterator with "
 1214|    250|                          "non-default-constructed iterator.");
 1215|       |    // Note: we use assert instead of ABSL_HARDENING_ASSERT here because this
 1216|       |    // changes the complexity of Equals from O(1) to O(log(N) + log(M)) where
 1217|       |    // N/M are sizes of the containers containing node_/other.node_.
 1218|    250|    assert(AreNodesFromSameContainer(node_, other.node_) &&
 1219|    250|           "Comparing iterators from different containers.");
 1220|    250|    assert_valid_generation(node_);
 1221|    250|    other.assert_valid_generation(other.node_);
 1222|    250|    return node_ == other.node_ && position_ == other.position_;
  ------------------
  |  Branch (1222:12): [True: 80, False: 170]
  |  Branch (1222:36): [True: 10, False: 70]
  ------------------
 1223|    250|  }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE5beginEv:
 1412|     84|  const_iterator begin() const { return const_iterator(leftmost()); }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8leftmostEv:
 1647|     84|  const node_type *leftmost() const { return root()->parent(); }
_ZN4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_EC2EPSG_:
 1104|     84|  explicit btree_iterator(Node *n) : btree_iterator(n, n->start()) {}
_ZN4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_EmmEv:
 1164|     78|  btree_iterator &operator--() {
 1165|     78|    decrement();
 1166|     78|    return *this;
 1167|     78|  }
_ZN4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_E9decrementEv:
 1250|     78|  void decrement() {
 1251|     78|    assert_valid_generation(node_);
 1252|     78|    if (node_->is_leaf() && --position_ >= node_->start()) {
  ------------------
  |  Branch (1252:9): [True: 66, False: 12]
  |  Branch (1252:29): [True: 58, False: 8]
  ------------------
 1253|     58|      return;
 1254|     58|    }
 1255|     20|    decrement_slow();
 1256|     20|  }
_ZN4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_E14decrement_slowEv:
 2131|     20|void btree_iterator<N, R, P>::decrement_slow() {
 2132|     20|  if (node_->is_leaf()) {
  ------------------
  |  Branch (2132:7): [True: 8, False: 12]
  ------------------
 2133|      8|    assert(position_ <= -1);
 2134|      8|    btree_iterator save(*this);
 2135|     16|    while (position_ < node_->start() && !node_->is_root()) {
  ------------------
  |  Branch (2135:12): [True: 8, False: 8]
  |  Branch (2135:42): [True: 8, False: 0]
  ------------------
 2136|      8|      assert(node_->parent()->child(node_->position()) == node_);
 2137|      8|      position_ = node_->position() - 1;
 2138|      8|      node_ = node_->parent();
 2139|      8|    }
 2140|       |    // TODO(ezb): assert we aren't decrementing begin() instead of handling.
 2141|      8|    if (position_ < node_->start()) {
  ------------------
  |  Branch (2141:9): [True: 0, False: 8]
  ------------------
 2142|      0|      *this = save;
 2143|      0|    }
 2144|     12|  } else {
 2145|     12|    assert(position_ >= node_->start());
 2146|     12|    node_ = node_->child(static_cast<field_type>(position_));
 2147|     12|    while (node_->is_internal()) {
  ------------------
  |  Branch (2147:12): [True: 0, False: 12]
  ------------------
 2148|      0|      node_ = node_->child(node_->finish());
 2149|      0|    }
 2150|     12|    position_ = node_->finish() - 1;
 2151|     12|  }
 2152|     20|}
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE7is_rootEv:
  723|     30|  bool is_root() const { return parent()->is_leaf(); }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE3endEv:
 1413|    166|  iterator end() { return iterator(rightmost(), rightmost()->finish()); }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9rightmostEv:
 1636|    344|  node_type *rightmost() { return rightmost_.template get<2>(); }
_ZNK4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_EneERKNS2_ISF_RS9_PS9_EE:
 1130|    166|  bool operator!=(const iterator &other) const {
 1131|    166|    return !Equals(other);
 1132|    166|  }
_ZNK4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_EptEv:
 1158|    162|  pointer operator->() const { return &operator*(); }
_ZNK4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_EdeEv:
 1148|    162|  reference operator*() const {
 1149|    162|    ABSL_HARDENING_ASSERT(node_ != nullptr);
  ------------------
  |  |  128|    162|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|    162|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1150|    162|    assert_valid_generation(node_);
 1151|    162|    ABSL_HARDENING_ASSERT(position_ >= node_->start());
  ------------------
  |  |  128|    162|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|    162|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1152|    162|    if (position_ >= node_->finish()) {
  ------------------
  |  Branch (1152:9): [True: 0, False: 162]
  ------------------
 1153|      0|      ABSL_HARDENING_ASSERT(!IsEndIterator() && "Dereferencing end() iterator");
  ------------------
  |  |  128|      0|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|      0|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1154|      0|      ABSL_HARDENING_ASSERT(position_ < node_->finish());
  ------------------
  |  |  128|      0|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|      0|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1155|      0|    }
 1156|    162|    return node_->value(static_cast<field_type>(position_));
 1157|    162|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE5valueEm:
  755|    162|  const_reference value(size_type i) const {
  756|    162|    return params_type::element(slot(i));
  757|    162|  }
_ZN4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_EppEv:
 1160|     82|  btree_iterator &operator++() {
 1161|     82|    increment();
 1162|     82|    return *this;
 1163|     82|  }
_ZN4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_E9incrementEv:
 1241|     82|  void increment() {
 1242|     82|    assert_valid_generation(node_);
 1243|     82|    if (node_->is_leaf() && ++position_ < node_->finish()) {
  ------------------
  |  Branch (1243:9): [True: 74, False: 8]
  |  Branch (1243:29): [True: 60, False: 14]
  ------------------
 1244|     60|      return;
 1245|     60|    }
 1246|     22|    increment_slow();
 1247|     22|  }
_ZN4absl12lts_2023012518container_internal14btree_iteratorIKNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERKS9_PSH_E14increment_slowEv:
 2107|     22|void btree_iterator<N, R, P>::increment_slow() {
 2108|     22|  if (node_->is_leaf()) {
  ------------------
  |  Branch (2108:7): [True: 14, False: 8]
  ------------------
 2109|     14|    assert(position_ >= node_->finish());
 2110|     14|    btree_iterator save(*this);
 2111|     26|    while (position_ == node_->finish() && !node_->is_root()) {
  ------------------
  |  Branch (2111:12): [True: 14, False: 12]
  |  Branch (2111:44): [True: 12, False: 2]
  ------------------
 2112|     12|      assert(node_->parent()->child(node_->position()) == node_);
 2113|     12|      position_ = node_->position();
 2114|     12|      node_ = node_->parent();
 2115|     12|    }
 2116|       |    // TODO(ezb): assert we aren't incrementing end() instead of handling.
 2117|     14|    if (position_ == node_->finish()) {
  ------------------
  |  Branch (2117:9): [True: 2, False: 12]
  ------------------
 2118|      2|      *this = save;
 2119|      2|    }
 2120|     14|  } else {
 2121|      8|    assert(position_ < node_->finish());
 2122|      8|    node_ = node_->child(static_cast<field_type>(position_ + 1));
 2123|      8|    while (node_->is_internal()) {
  ------------------
  |  Branch (2123:12): [True: 0, False: 8]
  ------------------
 2124|      0|      node_ = node_->start_child();
 2125|      0|    }
 2126|      8|    position_ = node_->start();
 2127|      8|  }
 2128|     22|}
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE18insert_hint_uniqueIS8_JRKS8_EEENSA_4pairINS1_14btree_iteratorINS1_10btree_nodeISD_EERS8_PS8_EEbEESO_RKT_DpOT0_:
 2277|     84|    -> std::pair<iterator, bool> {
 2278|     84|  if (!empty()) {
  ------------------
  |  Branch (2278:7): [True: 82, False: 2]
  ------------------
 2279|     82|    if (position == end() || compare_keys(key, position.key())) {
  ------------------
  |  Branch (2279:9): [True: 2, False: 80]
  |  Branch (2279:9): [True: 82, False: 0]
  |  Branch (2279:30): [True: 80, False: 0]
  ------------------
 2280|     82|      if (position == begin() || compare_keys(std::prev(position).key(), key)) {
  ------------------
  |  Branch (2280:11): [True: 0, False: 82]
  |  Branch (2280:11): [True: 78, False: 4]
  |  Branch (2280:34): [True: 78, False: 4]
  ------------------
 2281|       |        // prev.key() < key < position.key()
 2282|     78|        return {internal_emplace(position, std::forward<Args>(args)...), true};
 2283|     78|      }
 2284|     82|    } else if (compare_keys(position.key(), key)) {
  ------------------
  |  Branch (2284:16): [True: 0, False: 0]
  ------------------
 2285|      0|      ++position;
 2286|      0|      if (position == end() || compare_keys(key, position.key())) {
  ------------------
  |  Branch (2286:11): [True: 0, False: 0]
  |  Branch (2286:11): [True: 0, False: 0]
  |  Branch (2286:32): [True: 0, False: 0]
  ------------------
 2287|       |        // {original `position`}.key() < key < {current `position`}.key()
 2288|      0|        return {internal_emplace(position, std::forward<Args>(args)...), true};
 2289|      0|      }
 2290|      0|    } else {
 2291|       |      // position.key() == key
 2292|      0|      return {position, false};
 2293|      0|    }
 2294|     82|  }
 2295|      6|  return insert_unique(key, std::forward<Args>(args)...);
 2296|     84|}
_ZNK4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_EeqERKSI_:
 1124|    164|  bool operator==(const iterator &other) const {
 1125|    164|    return Equals(other);
 1126|    164|  }
_ZNK4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_E6EqualsENS2_IKSF_RKS9_PSK_EE:
 1210|    164|  bool Equals(const const_iterator other) const {
 1211|    164|    ABSL_HARDENING_ASSERT(((node_ == nullptr && other.node_ == nullptr) ||
  ------------------
  |  |  128|    164|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|    164|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1212|    164|                           (node_ != nullptr && other.node_ != nullptr)) &&
 1213|    164|                          "Comparing default-constructed iterator with "
 1214|    164|                          "non-default-constructed iterator.");
 1215|       |    // Note: we use assert instead of ABSL_HARDENING_ASSERT here because this
 1216|       |    // changes the complexity of Equals from O(1) to O(log(N) + log(M)) where
 1217|       |    // N/M are sizes of the containers containing node_/other.node_.
 1218|    164|    assert(AreNodesFromSameContainer(node_, other.node_) &&
 1219|    164|           "Comparing iterators from different containers.");
 1220|    164|    assert_valid_generation(node_);
 1221|    164|    other.assert_valid_generation(other.node_);
 1222|    164|    return node_ == other.node_ && position_ == other.position_;
  ------------------
  |  Branch (1222:12): [True: 54, False: 110]
  |  Branch (1222:36): [True: 2, False: 52]
  ------------------
 1223|    164|  }
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE12compare_keysIS8_S8_EEbRKT_RKT0_:
 1543|    166|  bool compare_keys(const K1 &a, const K2 &b) const {
 1544|    166|    return compare_internal::compare_result_as_less_than(key_comp()(a, b));
 1545|    166|  }
_ZNK4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_E3keyEv:
 1259|    166|  const key_type &key() const {
 1260|    166|    return node_->key(static_cast<size_type>(position_));
 1261|    166|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE5beginEv:
 1411|     82|  iterator begin() { return iterator(leftmost()); }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8leftmostEv:
 1646|     82|  node_type *leftmost() { return root()->parent(); }
_ZN4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_EmmEv:
 1164|     94|  btree_iterator &operator--() {
 1165|     94|    decrement();
 1166|     94|    return *this;
 1167|     94|  }
_ZN4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_E9decrementEv:
 1250|     94|  void decrement() {
 1251|     94|    assert_valid_generation(node_);
 1252|     94|    if (node_->is_leaf() && --position_ >= node_->start()) {
  ------------------
  |  Branch (1252:9): [True: 70, False: 24]
  |  Branch (1252:29): [True: 62, False: 8]
  ------------------
 1253|     62|      return;
 1254|     62|    }
 1255|     32|    decrement_slow();
 1256|     32|  }
_ZN4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_E14decrement_slowEv:
 2131|     32|void btree_iterator<N, R, P>::decrement_slow() {
 2132|     32|  if (node_->is_leaf()) {
  ------------------
  |  Branch (2132:7): [True: 8, False: 24]
  ------------------
 2133|      8|    assert(position_ <= -1);
 2134|      8|    btree_iterator save(*this);
 2135|     16|    while (position_ < node_->start() && !node_->is_root()) {
  ------------------
  |  Branch (2135:12): [True: 8, False: 8]
  |  Branch (2135:42): [True: 8, False: 0]
  ------------------
 2136|      8|      assert(node_->parent()->child(node_->position()) == node_);
 2137|      8|      position_ = node_->position() - 1;
 2138|      8|      node_ = node_->parent();
 2139|      8|    }
 2140|       |    // TODO(ezb): assert we aren't decrementing begin() instead of handling.
 2141|      8|    if (position_ < node_->start()) {
  ------------------
  |  Branch (2141:9): [True: 0, False: 8]
  ------------------
 2142|      0|      *this = save;
 2143|      0|    }
 2144|     24|  } else {
 2145|     24|    assert(position_ >= node_->start());
 2146|     24|    node_ = node_->child(static_cast<field_type>(position_));
 2147|     24|    while (node_->is_internal()) {
  ------------------
  |  Branch (2147:12): [True: 0, False: 24]
  ------------------
 2148|      0|      node_ = node_->child(node_->finish());
 2149|      0|    }
 2150|     24|    position_ = node_->finish() - 1;
 2151|     24|  }
 2152|     32|}
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE16internal_emplaceIJRKS8_EEENS1_14btree_iteratorINS1_10btree_nodeISD_EERS8_PS8_EESN_DpOT_:
 2786|     84|    -> iterator {
 2787|     84|  if (iter.node_->is_internal()) {
  ------------------
  |  Branch (2787:7): [True: 12, False: 72]
  ------------------
 2788|       |    // We can't insert on an internal node. Instead, we'll insert after the
 2789|       |    // previous value which is guaranteed to be on a leaf node.
 2790|     12|    --iter;
 2791|     12|    ++iter.position_;
 2792|     12|  }
 2793|     84|  const field_type max_count = iter.node_->max_count();
 2794|     84|  allocator_type *alloc = mutable_allocator();
 2795|     84|  if (iter.node_->count() == max_count) {
  ------------------
  |  Branch (2795:7): [True: 44, False: 40]
  ------------------
 2796|       |    // Make room in the leaf for the new item.
 2797|     44|    if (max_count < kNodeSlots) {
  ------------------
  |  Branch (2797:9): [True: 6, False: 38]
  ------------------
 2798|       |      // Insertion into the root where the root is smaller than the full node
 2799|       |      // size. Simply grow the size of the root node.
 2800|      6|      assert(iter.node_ == root());
 2801|      6|      iter.node_ = new_leaf_root_node(static_cast<field_type>(
 2802|      6|          (std::min)(static_cast<int>(kNodeSlots), 2 * max_count)));
 2803|       |      // Transfer the values from the old root to the new root.
 2804|      6|      node_type *old_root = root();
 2805|      6|      node_type *new_root = iter.node_;
 2806|      6|      new_root->transfer_n(old_root->count(), new_root->start(),
 2807|      6|                           old_root->start(), old_root, alloc);
 2808|      6|      new_root->set_finish(old_root->finish());
 2809|      6|      old_root->set_finish(old_root->start());
 2810|      6|      new_root->set_generation(old_root->generation());
 2811|      6|      node_type::clear_and_delete(old_root, alloc);
 2812|      6|      mutable_root() = mutable_rightmost() = new_root;
 2813|     38|    } else {
 2814|     38|      rebalance_or_split(&iter);
 2815|     38|    }
 2816|     44|  }
 2817|     84|  iter.node_->emplace_value(static_cast<field_type>(iter.position_), alloc,
 2818|     84|                            std::forward<Args>(args)...);
 2819|     84|  ++size_;
 2820|     84|  iter.update_generation();
 2821|     84|  return iter;
 2822|     84|}
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE18new_leaf_root_nodeEh:
 1676|      8|  node_type *new_leaf_root_node(field_type max_count) {
 1677|      8|    node_type *n = allocate(node_type::LeafSize(max_count));
 1678|      8|    n->init_leaf(max_count, /*parent=*/n);
 1679|      8|    return n;
 1680|      8|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8allocateEm:
 1659|     22|  node_type *allocate(size_type size) {
 1660|     22|    return reinterpret_cast<node_type *>(
 1661|     22|        absl::container_internal::Allocate<node_type::Alignment()>(
 1662|     22|            mutable_allocator(), size));
 1663|     22|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9init_leafEhPSE_:
  919|     22|  void init_leaf(field_type max_count, btree_node *parent) {
  920|     22|    set_generation(0);
  921|     22|    set_parent(parent);
  922|     22|    set_position(0);
  923|     22|    set_start(0);
  924|     22|    set_finish(0);
  925|     22|    set_max_count(max_count);
  926|     22|    absl::container_internal::SanitizerPoisonMemoryRegion(
  927|     22|        start_slot(), max_count * sizeof(slot_type));
  928|     22|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10set_parentEPSE_:
  671|     36|  void set_parent(btree_node *p) { *GetField<0>() = p; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm0EEEPNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  660|     36|  inline typename layout_type::template ElementType<N> *GetField() {
  661|       |    // We assert that we don't read from values that aren't there.
  662|     36|    assert(N < 4 || is_internal());
  663|     36|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  664|     36|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE12set_positionEh:
  677|     52|  void set_position(field_type v) { GetField<2>()[0] = v; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm2EEEPNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  660|    316|  inline typename layout_type::template ElementType<N> *GetField() {
  661|       |    // We assert that we don't read from values that aren't there.
  662|    316|    assert(N < 4 || is_internal());
  663|    316|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  664|    316|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9set_startEh:
  678|     22|  void set_start(field_type v) { GetField<2>()[1] = v; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13set_max_countEh:
  681|     24|  void set_max_count(field_type v) { GetField<2>()[3] = v; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10start_slotEv:
  674|     22|  slot_type *start_slot() { return slot(start()); }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10transfer_nEmmmPSE_PSC_:
  985|     54|                  allocator_type *alloc) {
  986|     54|    next_generation();
  987|     54|    for (slot_type *src = src_node->slot(src_i), *end = src + n,
  988|     54|                   *dest = slot(dest_i);
  989|    158|         src != end; ++src, ++dest) {
  ------------------
  |  Branch (989:10): [True: 104, False: 54]
  ------------------
  990|    104|      transfer(dest, src, alloc);
  991|    104|    }
  992|     54|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8transferEPS8_SF_PSC_:
  968|    430|  static void transfer(slot_type *dest, slot_type *src, allocator_type *alloc) {
  969|    430|    absl::container_internal::SanitizerUnpoisonObject(dest);
  970|    430|    params_type::transfer(alloc, dest, src);
  971|    430|    absl::container_internal::SanitizerPoisonObject(src);
  972|    430|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10set_finishEh:
  679|    206|  void set_finish(field_type v) { GetField<2>()[2] = v; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE14set_generationEj:
  744|     30|  void set_generation(uint32_t generation) {
  745|     30|    if (params_type::kEnableGenerations) GetField<1>()[0] = generation;
  ------------------
  |  Branch (745:9): [Folded - Ignored]
  ------------------
  746|     30|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE18rebalance_or_splitEPNS1_14btree_iteratorINS1_10btree_nodeISD_EERS8_PS8_EE:
 2583|     38|void btree<P>::rebalance_or_split(iterator *iter) {
 2584|     38|  node_type *&node = iter->node_;
 2585|     38|  int &insert_position = iter->position_;
 2586|     38|  assert(node->count() == node->max_count());
 2587|     38|  assert(kNodeSlots == node->max_count());
 2588|       |
 2589|       |  // First try to make room on the node by rebalancing.
 2590|     38|  node_type *parent = node->parent();
 2591|     38|  if (node != root()) {
  ------------------
  |  Branch (2591:7): [True: 36, False: 2]
  ------------------
 2592|     36|    if (node->position() > parent->start()) {
  ------------------
  |  Branch (2592:9): [True: 22, False: 14]
  ------------------
 2593|       |      // Try rebalancing with our left sibling.
 2594|     22|      node_type *left = parent->child(node->position() - 1);
 2595|     22|      assert(left->max_count() == kNodeSlots);
 2596|     22|      if (left->count() < kNodeSlots) {
  ------------------
  |  Branch (2596:11): [True: 10, False: 12]
  ------------------
 2597|       |        // We bias rebalancing based on the position being inserted. If we're
 2598|       |        // inserting at the end of the right node then we bias rebalancing to
 2599|       |        // fill up the left node.
 2600|     10|        field_type to_move =
 2601|     10|            (kNodeSlots - left->count()) /
 2602|     10|            (1 + (static_cast<field_type>(insert_position) < kNodeSlots));
 2603|     10|        to_move = (std::max)(field_type{1}, to_move);
 2604|       |
 2605|     10|        if (static_cast<field_type>(insert_position) - to_move >=
  ------------------
  |  Branch (2605:13): [True: 8, False: 2]
  ------------------
 2606|     10|                node->start() ||
 2607|     10|            left->count() + to_move < kNodeSlots) {
  ------------------
  |  Branch (2607:13): [True: 2, False: 0]
  ------------------
 2608|     10|          left->rebalance_right_to_left(to_move, node, mutable_allocator());
 2609|       |
 2610|     10|          assert(node->max_count() - node->count() == to_move);
 2611|     10|          insert_position = static_cast<int>(
 2612|     10|              static_cast<field_type>(insert_position) - to_move);
 2613|     10|          if (insert_position < node->start()) {
  ------------------
  |  Branch (2613:15): [True: 2, False: 8]
  ------------------
 2614|      2|            insert_position = insert_position + left->count() + 1;
 2615|      2|            node = left;
 2616|      2|          }
 2617|       |
 2618|     10|          assert(node->count() < node->max_count());
 2619|     10|          return;
 2620|     10|        }
 2621|     10|      }
 2622|     22|    }
 2623|       |
 2624|     26|    if (node->position() < parent->finish()) {
  ------------------
  |  Branch (2624:9): [True: 24, False: 2]
  ------------------
 2625|       |      // Try rebalancing with our right sibling.
 2626|     24|      node_type *right = parent->child(node->position() + 1);
 2627|     24|      assert(right->max_count() == kNodeSlots);
 2628|     24|      if (right->count() < kNodeSlots) {
  ------------------
  |  Branch (2628:11): [True: 16, False: 8]
  ------------------
 2629|       |        // We bias rebalancing based on the position being inserted. If we're
 2630|       |        // inserting at the beginning of the left node then we bias rebalancing
 2631|       |        // to fill up the right node.
 2632|     16|        field_type to_move = (kNodeSlots - right->count()) /
 2633|     16|                             (1 + (insert_position > node->start()));
 2634|     16|        to_move = (std::max)(field_type{1}, to_move);
 2635|       |
 2636|     16|        if (static_cast<field_type>(insert_position) <=
  ------------------
  |  Branch (2636:13): [True: 10, False: 6]
  ------------------
 2637|     16|                node->finish() - to_move ||
 2638|     16|            right->count() + to_move < kNodeSlots) {
  ------------------
  |  Branch (2638:13): [True: 6, False: 0]
  ------------------
 2639|     16|          node->rebalance_left_to_right(to_move, right, mutable_allocator());
 2640|       |
 2641|     16|          if (insert_position > node->finish()) {
  ------------------
  |  Branch (2641:15): [True: 6, False: 10]
  ------------------
 2642|      6|            insert_position = insert_position - node->count() - 1;
 2643|      6|            node = right;
 2644|      6|          }
 2645|       |
 2646|     16|          assert(node->count() < node->max_count());
 2647|     16|          return;
 2648|     16|        }
 2649|     16|      }
 2650|     24|    }
 2651|       |
 2652|       |    // Rebalancing failed, make sure there is room on the parent node for a new
 2653|       |    // value.
 2654|     10|    assert(parent->max_count() == kNodeSlots);
 2655|     10|    if (parent->count() == kNodeSlots) {
  ------------------
  |  Branch (2655:9): [True: 0, False: 10]
  ------------------
 2656|      0|      iterator parent_iter(node->parent(), node->position());
 2657|      0|      rebalance_or_split(&parent_iter);
 2658|      0|    }
 2659|     10|  } else {
 2660|       |    // Rebalancing not possible because this is the root node.
 2661|       |    // Create a new root node and set the current root node as the child of the
 2662|       |    // new root.
 2663|      2|    parent = new_internal_node(parent);
 2664|      2|    parent->set_generation(root()->generation());
 2665|      2|    parent->init_child(parent->start(), root());
 2666|      2|    mutable_root() = parent;
 2667|       |    // If the former root was a leaf node, then it's now the rightmost node.
 2668|      2|    assert(parent->start_child()->is_internal() ||
 2669|      2|           parent->start_child() == rightmost());
 2670|      2|  }
 2671|       |
 2672|       |  // Split the node.
 2673|     12|  node_type *split_node;
 2674|     12|  if (node->is_leaf()) {
  ------------------
  |  Branch (2674:7): [True: 12, False: 0]
  ------------------
 2675|     12|    split_node = new_leaf_node(parent);
 2676|     12|    node->split(insert_position, split_node, mutable_allocator());
 2677|     12|    if (rightmost() == node) mutable_rightmost() = split_node;
  ------------------
  |  Branch (2677:9): [True: 4, False: 8]
  ------------------
 2678|     12|  } else {
 2679|      0|    split_node = new_internal_node(parent);
 2680|      0|    node->split(insert_position, split_node, mutable_allocator());
 2681|      0|  }
 2682|       |
 2683|     12|  if (insert_position > node->finish()) {
  ------------------
  |  Branch (2683:7): [True: 10, False: 2]
  ------------------
 2684|     10|    insert_position = insert_position - node->count() - 1;
 2685|     10|    node = split_node;
 2686|     10|  }
 2687|     12|}
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE23rebalance_right_to_leftEhPSE_PSC_:
 1828|     10|                                            allocator_type *alloc) {
 1829|     10|  assert(parent() == right->parent());
 1830|     10|  assert(position() + 1 == right->position());
 1831|     10|  assert(right->count() >= count());
 1832|     10|  assert(to_move >= 1);
 1833|     10|  assert(to_move <= right->count());
 1834|       |
 1835|       |  // 1) Move the delimiting value in the parent to the left node.
 1836|     10|  transfer(finish(), position(), parent(), alloc);
 1837|       |
 1838|       |  // 2) Move the (to_move - 1) values from the right node to the left node.
 1839|     10|  transfer_n(to_move - 1, finish() + 1, right->start(), right, alloc);
 1840|       |
 1841|       |  // 3) Move the new delimiting value to the parent from the right node.
 1842|     10|  parent()->transfer(position(), right->start() + to_move - 1, right, alloc);
 1843|       |
 1844|       |  // 4) Shift the values in the right node to their correct positions.
 1845|     10|  right->transfer_n(right->count() - to_move, right->start(),
 1846|     10|                    right->start() + to_move, right, alloc);
 1847|       |
 1848|     10|  if (is_internal()) {
  ------------------
  |  Branch (1848:7): [True: 0, False: 10]
  ------------------
 1849|       |    // Move the child pointers from the right to the left node.
 1850|      0|    for (field_type i = 0; i < to_move; ++i) {
  ------------------
  |  Branch (1850:28): [True: 0, False: 0]
  ------------------
 1851|      0|      init_child(finish() + i + 1, right->child(i));
 1852|      0|    }
 1853|      0|    for (field_type i = right->start(); i <= right->finish() - to_move; ++i) {
  ------------------
  |  Branch (1853:41): [True: 0, False: 0]
  ------------------
 1854|      0|      assert(i + to_move <= right->max_count());
 1855|      0|      right->init_child(i, right->child(i + to_move));
 1856|      0|      right->clear_child(i + to_move);
 1857|      0|    }
 1858|      0|  }
 1859|       |
 1860|       |  // Fixup `finish` on the left and right nodes.
 1861|     10|  set_finish(finish() + to_move);
 1862|     10|  right->set_finish(right->finish() - to_move);
 1863|     10|}
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8transferEmmPSE_PSC_:
  976|     52|                btree_node *src_node, allocator_type *alloc) {
  977|     52|    next_generation();
  978|     52|    transfer(slot(dest_i), src_node->slot(src_i), alloc);
  979|     52|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE11clear_childEh:
  763|      8|  void clear_child(field_type i) {
  764|      8|    absl::container_internal::SanitizerPoisonObject(&mutable_child(i));
  765|      8|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13mutable_childEh:
  762|     70|  btree_node *&mutable_child(field_type i) { return GetField<4>()[i]; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE8GetFieldILm4EEEPNSA_13tuple_elementIXT_ENSA_5tupleIJPSE_jhS8_SI_EEEE4typeEv:
  660|     70|  inline typename layout_type::template ElementType<N> *GetField() {
  661|       |    // We assert that we don't read from values that aren't there.
  662|     70|    assert(N < 4 || is_internal());
  663|     70|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  664|     70|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE23rebalance_left_to_rightEhPSE_PSC_:
 1868|     16|                                            allocator_type *alloc) {
 1869|     16|  assert(parent() == right->parent());
 1870|     16|  assert(position() + 1 == right->position());
 1871|     16|  assert(count() >= right->count());
 1872|     16|  assert(to_move >= 1);
 1873|     16|  assert(to_move <= count());
 1874|       |
 1875|       |  // Values in the right node are shifted to the right to make room for the
 1876|       |  // new to_move values. Then, the delimiting value in the parent and the
 1877|       |  // other (to_move - 1) values in the left node are moved into the right node.
 1878|       |  // Lastly, a new delimiting value is moved from the left node into the
 1879|       |  // parent, and the remaining empty left node entries are destroyed.
 1880|       |
 1881|       |  // 1) Shift existing values in the right node to their correct positions.
 1882|     16|  right->transfer_n_backward(right->count(), right->start() + to_move,
 1883|     16|                             right->start(), right, alloc);
 1884|       |
 1885|       |  // 2) Move the delimiting value in the parent to the right node.
 1886|     16|  right->transfer(right->start() + to_move - 1, position(), parent(), alloc);
 1887|       |
 1888|       |  // 3) Move the (to_move - 1) values from the left node to the right node.
 1889|     16|  right->transfer_n(to_move - 1, right->start(), finish() - (to_move - 1), this,
 1890|     16|                    alloc);
 1891|       |
 1892|       |  // 4) Move the new delimiting value to the parent from the left node.
 1893|     16|  parent()->transfer(position(), finish() - to_move, this, alloc);
 1894|       |
 1895|     16|  if (is_internal()) {
  ------------------
  |  Branch (1895:7): [True: 0, False: 16]
  ------------------
 1896|       |    // Move the child pointers from the left to the right node.
 1897|      0|    for (field_type i = right->finish() + 1; i > right->start(); --i) {
  ------------------
  |  Branch (1897:46): [True: 0, False: 0]
  ------------------
 1898|      0|      right->init_child(i - 1 + to_move, right->child(i - 1));
 1899|      0|      right->clear_child(i - 1);
 1900|      0|    }
 1901|      0|    for (field_type i = 1; i <= to_move; ++i) {
  ------------------
  |  Branch (1901:28): [True: 0, False: 0]
  ------------------
 1902|      0|      right->init_child(i - 1, child(finish() - to_move + i));
 1903|      0|      clear_child(finish() - to_move + i);
 1904|      0|    }
 1905|      0|  }
 1906|       |
 1907|       |  // Fixup the counts on the left and right nodes.
 1908|     16|  set_finish(finish() - to_move);
 1909|     16|  right->set_finish(right->finish() + to_move);
 1910|     16|}
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE19transfer_n_backwardEmmmPSE_PSC_:
  998|     92|                           allocator_type *alloc) {
  999|     92|    next_generation();
 1000|     92|    for (slot_type *src = src_node->slot(src_i + n), *end = src - n,
 1001|     92|                   *dest = slot(dest_i + n);
 1002|    366|         src != end; --src, --dest) {
  ------------------
  |  Branch (1002:10): [True: 274, False: 92]
  ------------------
 1003|       |      // If we modified the loop index calculations above to avoid the -1s here,
 1004|       |      // it would result in UB in the computation of `end` (and possibly `src`
 1005|       |      // as well, if n == 0), since slot() is effectively an array index and it
 1006|       |      // is UB to compute the address of any out-of-bounds array element except
 1007|       |      // for one-past-the-end.
 1008|    274|      transfer(dest - 1, src - 1, alloc);
 1009|    274|    }
 1010|     92|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE17new_internal_nodeEPNS1_10btree_nodeISD_EE:
 1666|      2|  node_type *new_internal_node(node_type *parent) {
 1667|      2|    node_type *n = allocate(node_type::InternalSize());
 1668|      2|    n->init_internal(parent);
 1669|      2|    return n;
 1670|      2|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13init_internalEPSE_:
  929|      2|  void init_internal(btree_node *parent) {
  930|      2|    init_leaf(kNodeSlots, parent);
  931|       |    // Set `max_count` to a sentinel value to indicate that this node is
  932|       |    // internal.
  933|      2|    set_max_count(kInternalNodeMaxCount);
  934|      2|    absl::container_internal::SanitizerPoisonMemoryRegion(
  935|      2|        &mutable_child(start()), (kNodeSlots + 1) * sizeof(btree_node *));
  936|      2|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10init_childEhPSE_:
  771|     14|  void init_child(field_type i, btree_node *c) {
  772|     14|    set_child(i, c);
  773|     14|    c->set_parent(this);
  774|     14|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE9set_childEhPSE_:
  766|     30|  void set_child(field_type i, btree_node *c) {
  767|     30|    absl::container_internal::SanitizerUnpoisonObject(&mutable_child(i));
  768|     30|    mutable_child(i) = c;
  769|     30|    c->set_position(i);
  770|     30|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13new_leaf_nodeEPNS1_10btree_nodeISD_EE:
 1671|     12|  node_type *new_leaf_node(node_type *parent) {
 1672|     12|    node_type *n = allocate(node_type::LeafSize());
 1673|     12|    n->init_leaf(kNodeSlots, parent);
 1674|     12|    return n;
 1675|     12|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE5splitEiPSE_PSC_:
 1914|     12|                          allocator_type *alloc) {
 1915|     12|  assert(dest->count() == 0);
 1916|     12|  assert(max_count() == kNodeSlots);
 1917|       |
 1918|       |  // We bias the split based on the position being inserted. If we're
 1919|       |  // inserting at the beginning of the left node then bias the split to put
 1920|       |  // more values on the right node. If we're inserting at the end of the
 1921|       |  // right node then bias the split to put more values on the left node.
 1922|     12|  if (insert_position == start()) {
  ------------------
  |  Branch (1922:7): [True: 0, False: 12]
  ------------------
 1923|      0|    dest->set_finish(dest->start() + finish() - 1);
 1924|     12|  } else if (insert_position == kNodeSlots) {
  ------------------
  |  Branch (1924:14): [True: 4, False: 8]
  ------------------
 1925|      4|    dest->set_finish(dest->start());
 1926|      8|  } else {
 1927|      8|    dest->set_finish(dest->start() + count() / 2);
 1928|      8|  }
 1929|     12|  set_finish(finish() - dest->count());
 1930|     12|  assert(count() >= 1);
 1931|       |
 1932|       |  // Move values from the left sibling to the right sibling.
 1933|     12|  dest->transfer_n(dest->count(), dest->start(), finish(), this, alloc);
 1934|       |
 1935|       |  // The split key is the largest value in the left sibling.
 1936|     12|  --mutable_finish();
 1937|     12|  parent()->emplace_value(position(), alloc, finish_slot());
 1938|     12|  value_destroy(finish(), alloc);
 1939|     12|  parent()->init_child(position() + 1, dest);
 1940|       |
 1941|     12|  if (is_internal()) {
  ------------------
  |  Branch (1941:7): [True: 0, False: 12]
  ------------------
 1942|      0|    for (field_type i = dest->start(), j = finish() + 1; i <= dest->finish();
  ------------------
  |  Branch (1942:58): [True: 0, False: 0]
  ------------------
 1943|      0|         ++i, ++j) {
 1944|      0|      assert(child(j) != nullptr);
 1945|      0|      dest->init_child(i, child(j));
 1946|      0|      clear_child(j);
 1947|      0|    }
 1948|      0|  }
 1949|     12|}
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE14mutable_finishEv:
  672|     12|  field_type &mutable_finish() { return GetField<2>()[2]; }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13emplace_valueIJPS8_EEEvhPSC_DpOT_:
 1781|     12|                                         Args &&...args) {
 1782|     12|  assert(i >= start());
 1783|     12|  assert(i <= finish());
 1784|       |  // Shift old values to create space for new value and then construct it in
 1785|       |  // place.
 1786|     12|  if (i < finish()) {
  ------------------
  |  Branch (1786:7): [True: 8, False: 4]
  ------------------
 1787|      8|    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
 1788|      8|                        alloc);
 1789|      8|  }
 1790|     12|  value_init(static_cast<field_type>(i), alloc, std::forward<Args>(args)...);
 1791|     12|  set_finish(finish() + 1);
 1792|       |
 1793|     12|  if (is_internal() && finish() > i + 1) {
  ------------------
  |  Branch (1793:7): [True: 12, False: 0]
  |  Branch (1793:24): [True: 8, False: 4]
  ------------------
 1794|     24|    for (field_type j = finish(); j > i + 1; --j) {
  ------------------
  |  Branch (1794:35): [True: 16, False: 8]
  ------------------
 1795|     16|      set_child(j, child(j - 1));
 1796|     16|    }
 1797|      8|    clear_child(i + 1);
 1798|      8|  }
 1799|     12|}
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10value_initIJPS8_EEEvhPSC_DpOT_:
  949|     12|  void value_init(const field_type i, allocator_type *alloc, Args &&...args) {
  950|     12|    next_generation();
  951|     12|    absl::container_internal::SanitizerUnpoisonObject(slot(i));
  952|     12|    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
  953|     12|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE11finish_slotEv:
  675|     12|  slot_type *finish_slot() { return slot(finish()); }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13value_destroyEhPSC_:
  954|     12|  void value_destroy(const field_type i, allocator_type *alloc) {
  955|     12|    next_generation();
  956|     12|    params_type::destroy(alloc, slot(i));
  957|     12|    absl::container_internal::SanitizerPoisonObject(slot(i));
  958|     12|  }
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13emplace_valueIJRKS8_EEEvhPSC_DpOT_:
 1781|     84|                                         Args &&...args) {
 1782|     84|  assert(i >= start());
 1783|     84|  assert(i <= finish());
 1784|       |  // Shift old values to create space for new value and then construct it in
 1785|       |  // place.
 1786|     84|  if (i < finish()) {
  ------------------
  |  Branch (1786:7): [True: 68, False: 16]
  ------------------
 1787|     68|    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
 1788|     68|                        alloc);
 1789|     68|  }
 1790|     84|  value_init(static_cast<field_type>(i), alloc, std::forward<Args>(args)...);
 1791|     84|  set_finish(finish() + 1);
 1792|       |
 1793|     84|  if (is_internal() && finish() > i + 1) {
  ------------------
  |  Branch (1793:7): [True: 0, False: 84]
  |  Branch (1793:24): [True: 0, False: 0]
  ------------------
 1794|      0|    for (field_type j = finish(); j > i + 1; --j) {
  ------------------
  |  Branch (1794:35): [True: 0, False: 0]
  ------------------
 1795|      0|      set_child(j, child(j - 1));
 1796|      0|    }
 1797|      0|    clear_child(i + 1);
 1798|      0|  }
 1799|     84|}
_ZN4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE10value_initIJRKS8_EEEvhPSC_DpOT_:
  949|     84|  void value_init(const field_type i, allocator_type *alloc, Args &&...args) {
  950|     84|    next_generation();
  951|     84|    absl::container_internal::SanitizerUnpoisonObject(slot(i));
  952|     84|    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
  953|     84|  }
_ZN4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13insert_uniqueIS8_JRKS8_EEENSA_4pairINS1_14btree_iteratorINS1_10btree_nodeISD_EERS8_PS8_EEbEERKT_DpOT0_:
 2250|      6|    -> std::pair<iterator, bool> {
 2251|      6|  if (empty()) {
  ------------------
  |  Branch (2251:7): [True: 2, False: 4]
  ------------------
 2252|      2|    mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
 2253|      2|  }
 2254|       |
 2255|      6|  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
 2256|      6|  iterator iter = res.value;
 2257|       |
 2258|      6|  if (res.HasMatch()) {
  ------------------
  |  Branch (2258:7): [Folded - Ignored]
  ------------------
 2259|      0|    if (res.IsEq()) {
  ------------------
  |  Branch (2259:9): [Folded - Ignored]
  ------------------
 2260|       |      // The key already exists in the tree, do nothing.
 2261|      0|      return {iter, false};
 2262|      0|    }
 2263|      6|  } else {
 2264|      6|    iterator last = internal_last(iter);
 2265|      6|    if (last.node_ && !compare_keys(key, last.key())) {
  ------------------
  |  Branch (2265:9): [True: 4, False: 2]
  |  Branch (2265:23): [True: 0, False: 4]
  ------------------
 2266|       |      // The key already exists in the tree, do nothing.
 2267|      0|      return {last, false};
 2268|      0|    }
 2269|      6|  }
 2270|      6|  return {internal_emplace(iter, std::forward<Args>(args)...), true};
 2271|      6|}
_ZNK4absl12lts_2023012518container_internal5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE15internal_locateIS8_EENS1_12SearchResultINS1_14btree_iteratorINS1_10btree_nodeISD_EERS8_PS8_EELb0EEERKT_:
 2827|      6|    -> SearchResult<iterator, is_key_compare_to::value> {
 2828|      6|  iterator iter(const_cast<node_type *>(root()));
 2829|      6|  for (;;) {
 2830|      6|    SearchResult<size_type, is_key_compare_to::value> res =
 2831|      6|        iter.node_->lower_bound(key, key_comp());
 2832|      6|    iter.position_ = static_cast<int>(res.value);
 2833|      6|    if (res.IsEq()) {
  ------------------
  |  Branch (2833:9): [Folded - Ignored]
  ------------------
 2834|      0|      return {iter, MatchKind::kEq};
 2835|      0|    }
 2836|       |    // Note: in the non-key-compare-to case, we don't need to walk all the way
 2837|       |    // down the tree if the keys are equal, but determining equality would
 2838|       |    // require doing an extra comparison on each node on the way down, and we
 2839|       |    // will need to go all the way to the leaf node in the expected case.
 2840|      6|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (2840:9): [True: 6, False: 0]
  ------------------
 2841|      6|      break;
 2842|      6|    }
 2843|      0|    iter.node_ = iter.node_->child(static_cast<field_type>(iter.position_));
 2844|      0|  }
 2845|       |  // Note: in the non-key-compare-to case, the key may actually be equivalent
 2846|       |  // here (and the MatchKind::kNe is ignored).
 2847|      6|  return {iter, MatchKind::kNe};
 2848|      6|}
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE11lower_boundIS8_EENS1_12SearchResultImLb0EEERKT_RKNS1_19key_compare_adapterIS9_S8_E15checked_compareE:
  779|      6|      const K &k, const key_compare &comp) const {
  780|      6|    return use_linear_search::value ? linear_search(k, comp)
  ------------------
  |  Branch (780:12): [Folded - Ignored]
  ------------------
  781|      6|                                    : binary_search(k, comp);
  782|      6|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE13binary_searchIS8_NS1_19key_compare_adapterIS9_S8_E15checked_compareEEENS1_12SearchResultImXsr23btree_is_key_compare_toIT0_S8_EE5valueEEERKT_RKSK_:
  800|      6|  binary_search(const K &k, const Compare &comp) const {
  801|      6|    return binary_search_impl(k, start(), finish(), comp,
  802|      6|                              btree_is_key_compare_to<Compare, key_type>());
  803|      6|  }
_ZNK4absl12lts_2023012518container_internal10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EELi256ELb0EEEE18binary_search_implIS8_NS1_19key_compare_adapterIS9_S8_E15checked_compareEEENS1_12SearchResultImLb0EEERKT_mmRKT0_NSA_17integral_constantIbLb0EEE:
  843|      6|      std::false_type /* IsCompareTo */) const {
  844|     16|    while (s != e) {
  ------------------
  |  Branch (844:12): [True: 10, False: 6]
  ------------------
  845|     10|      const size_type mid = (s + e) >> 1;
  846|     10|      if (comp(key(mid), k)) {
  ------------------
  |  Branch (846:11): [True: 0, False: 10]
  ------------------
  847|      0|        s = mid + 1;
  848|     10|      } else {
  849|     10|        e = mid;
  850|     10|      }
  851|     10|    }
  852|      6|    return SearchResult<size_type, false>{s};
  853|      6|  }
_ZN4absl12lts_2023012518container_internal12SearchResultINS1_14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS9_13SymbolCompareENSt3__19allocatorISA_EELi256ELb0EEEEERSA_PSA_EELb0EEC2ESJ_NS1_9MatchKindE:
  479|      6|  SearchResult(V v, MatchKind /*match*/) : value(v) {}
_ZN4absl12lts_2023012518container_internal14btree_iteratorINS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEERS9_PS9_EC2IKSF_RKS9_PSL_Li0EEENS2_IT_T0_T1_EE:
 1208|     84|        position_(other.position_) {}

_ZN4absl12lts_2023012518container_internal15btree_containerINS1_5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS8_11FileCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEEC2ERKSA_RKSD_:
   77|      2|      : tree_(comp, alloc) {}
_ZN4absl12lts_2023012518container_internal15btree_containerINS1_5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEEC2ERKSA_RKSD_:
   77|      2|      : tree_(comp, alloc) {}
_ZN4absl12lts_2023012518container_internal15btree_containerINS1_5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex14ExtensionEntryENS8_16ExtensionCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEEC2ERKSA_RKSD_:
   77|      2|      : tree_(comp, alloc) {}
_ZN4absl12lts_2023012518container_internal19btree_set_containerINS1_5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS8_11FileCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEE6insertEOS9_:
  304|     12|  std::pair<iterator, bool> insert(value_type &&v) {
  305|     12|    return this->tree_.insert_unique(params_type::key(v), std::move(v));
  306|     12|  }
_ZNK4absl12lts_2023012518container_internal15btree_containerINS1_5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEE11upper_boundIS9_EENS1_14btree_iteratorIKNS1_10btree_nodeISE_EERKS9_PSM_EERSM_:
  142|     84|  const_iterator upper_bound(const key_arg<K> &key) const {
  143|     84|    return tree_.upper_bound(key);
  144|     84|  }
_ZNK4absl12lts_2023012518container_internal15btree_containerINS1_5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEE5beginEv:
   99|     84|  const_iterator begin() const { return tree_.begin(); }
_ZN4absl12lts_2023012518container_internal15btree_containerINS1_5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEE3endEv:
  101|     84|  iterator end() { return tree_.end(); }
_ZNK4absl12lts_2023012518container_internal15btree_containerINS1_5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEE8key_compEv:
  233|     84|  key_compare key_comp() const { return key_compare(tree_.key_comp()); }
_ZN4absl12lts_2023012518container_internal19btree_set_containerINS1_5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEE6insertENS1_14btree_iteratorIKNS1_10btree_nodeISE_EERKS9_PSL_EESM_:
  315|     84|  iterator insert(const_iterator hint, const value_type &v) {
  316|     84|    return this->tree_
  317|     84|        .insert_hint_unique(iterator(hint), params_type::key(v), v)
  318|     84|        .first;
  319|     84|  }
_ZNK4absl12lts_2023012518container_internal15btree_containerINS1_5btreeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS8_11FileCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEE8key_compEv:
  233|     12|  key_compare key_comp() const { return key_compare(tree_.key_comp()); }

_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEEvE7destroyINSt3__19allocatorIS9_EEEEvPT_PS9_:
   49|      8|  static void destroy(Alloc* alloc, slot_type* slot) {
   50|      8|    Policy::destroy(alloc, slot);
   51|      8|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEEvE7elementISA_EEDTclsrT_7elementfp_EEPS9_:
   75|     16|      -> decltype(P::element(slot)) {
   76|     16|    return P::element(slot);
   77|     16|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEEvE8transferINSt3__19allocatorIS9_EEEEvPT_PS9_SI_:
   65|      8|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   66|      8|    transfer_impl(alloc, new_slot, old_slot, Rank0{});
   67|      8|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEEvE13transfer_implINSt3__19allocatorIS9_EEEEvPT_PS9_SI_NSB_5Rank2E:
  122|      8|                            slot_type* old_slot, Rank2) {
  123|      8|    construct(alloc, new_slot, std::move(element(old_slot)));
  124|      8|    destroy(alloc, old_slot);
  125|      8|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEEvE9constructINSt3__19allocatorIS9_EEJS9_EEEvPT_PS9_DpOT0_:
   42|      8|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   43|      8|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   44|      8|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEEvE9constructINSt3__19allocatorIS9_EEJRKS9_EEEvPT_PS9_DpOT0_:
   42|     12|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   43|     12|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   44|     12|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEvE7destroyINSt3__19allocatorIS8_EEEEvPT_PS8_:
   49|    442|  static void destroy(Alloc* alloc, slot_type* slot) {
   50|    442|    Policy::destroy(alloc, slot);
   51|    442|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEEvE7destroyINSt3__19allocatorIS8_EEEEvPT_PS8_:
   49|     26|  static void destroy(Alloc* alloc, slot_type* slot) {
   50|     26|    Policy::destroy(alloc, slot);
   51|     26|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEEvE8transferINSt3__19allocatorIS8_EEEEvPT_PS8_SH_:
   65|     26|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   66|     26|    transfer_impl(alloc, new_slot, old_slot, Rank0{});
   67|     26|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEEvE13transfer_implINSt3__19allocatorIS8_EEEEvPT_PS8_SH_NSA_5Rank2E:
  122|     26|                            slot_type* old_slot, Rank2) {
  123|     26|    construct(alloc, new_slot, std::move(element(old_slot)));
  124|     26|    destroy(alloc, old_slot);
  125|     26|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEEvE9constructINSt3__19allocatorIS8_EEJS8_EEEvPT_PS8_DpOT0_:
   42|     38|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   43|     38|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   44|     38|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEEvE7elementIS9_EEDTclsrT_7elementfp_EEPS8_:
   75|     26|      -> decltype(P::element(slot)) {
   76|     26|    return P::element(slot);
   77|     26|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEvE7elementIS9_EEDTclsrT_7elementfp_EEPKS8_:
   79|    162|  static auto element(const slot_type* slot) -> decltype(P::element(slot)) {
   80|    162|    return P::element(slot);
   81|    162|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEvE8transferINSt3__19allocatorIS8_EEEEvPT_PS8_SH_:
   65|    430|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   66|    430|    transfer_impl(alloc, new_slot, old_slot, Rank0{});
   67|    430|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEvE13transfer_implINSt3__19allocatorIS8_EEEEvPT_PS8_SH_NSA_5Rank2E:
  122|    430|                            slot_type* old_slot, Rank2) {
  123|    430|    construct(alloc, new_slot, std::move(element(old_slot)));
  124|    430|    destroy(alloc, old_slot);
  125|    430|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEvE9constructINSt3__19allocatorIS8_EEJS8_EEEvPT_PS8_DpOT0_:
   42|    430|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   43|    430|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   44|    430|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEvE7elementIS9_EEDTclsrT_7elementfp_EEPS8_:
   75|    430|      -> decltype(P::element(slot)) {
   76|    430|    return P::element(slot);
   77|    430|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEvE9constructINSt3__19allocatorIS8_EEJPS8_EEEvPT_SF_DpOT0_:
   42|     12|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   43|     12|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   44|     12|  }
_ZN4absl12lts_2023012518container_internal20common_policy_traitsINS1_15set_slot_policyIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEvE9constructINSt3__19allocatorIS8_EEJRKS8_EEEvPT_PS8_DpOT0_:
   42|     84|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   43|     84|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   44|     84|  }

_ZNR4absl12lts_2023012518container_internal15CompressedTupleIJmNS1_20HashtablezInfoHandleEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS4_XT_EE4typeEv:
  259|     38|  ElemT<I>& get() & {
  260|     38|    return StorageT<I>::get();
  261|     38|  }
_ZNR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageImLm0ELb0EE3getEv:
  110|     38|  T& get() & { return value; }
_ZNR4absl12lts_2023012518container_internal15CompressedTupleIJmNS1_20HashtablezInfoHandleEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS4_XT_EE4typeEv:
  259|     30|  ElemT<I>& get() & {
  260|     30|    return StorageT<I>::get();
  261|     30|  }
_ZNR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_20HashtablezInfoHandleELm1ELb1EE3getEv:
  124|     30|  T& get() & { return *this; }
_ZNKR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EE3getEv:
  109|    102|  constexpr const T& get() const& { return value; }
_ZNR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EE3getEv:
  110|    166|  T& get() & { return value; }
_ZN4absl12lts_2023012518container_internal15CompressedTupleIJmNS1_20HashtablezInfoHandleEEEC2IjJS3_ELb1EEEOT_DpOT0_:
  256|      4|                                             absl::forward<Vs>(base)...) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJmNS1_20HashtablezInfoHandleEEEENS0_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJjS5_EEENS0_10in_place_tEDpOT_:
  144|      4|      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageImLm0ELb0EEC2IjEENS0_10in_place_tEOT_:
  108|      4|      : value(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_20HashtablezInfoHandleELm1ELb1EEC2IS4_EENS0_10in_place_tEOT_:
  121|      8|      : T(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EEC2IS4_EENS0_10in_place_tEOT_:
  108|      4|      : value(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal15CompressedTupleIJmNS1_20HashtablezInfoHandleEEEC2IRmJS3_ELb1EEEOT_DpOT0_:
  256|      4|                                             absl::forward<Vs>(base)...) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJmNS1_20HashtablezInfoHandleEEEENS0_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJRmS5_EEENS0_10in_place_tEDpOT_:
  144|      4|      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageImLm0ELb0EEC2IRmEENS0_10in_place_tEOT_:
  108|      4|      : value(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_6HashEqIPKN6google8protobuf10DescriptorEvE4HashELm1ELb1EEC2ISB_EENS0_10in_place_tEOT_:
  121|      2|      : T(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_6HashEqIPKN6google8protobuf10DescriptorEvE2EqELm2ELb1EEC2ISB_EENS0_10in_place_tEOT_:
  121|      2|      : T(absl::forward<V>(v)) {}
message.cc:_ZNKR4absl12lts_2023012518container_internal15CompressedTupleIJNS1_12CommonFieldsEN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENS7_18DescriptorByNameEqENSt3__19allocatorIPKNS5_8internal15DescriptorTableEEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISH_XT_EE4typeEv:
  264|    102|  constexpr const ElemT<I>& get() const& {
  265|    102|    return StorageT<I>::get();
  266|    102|  }
message.cc:_ZNR4absl12lts_2023012518container_internal15CompressedTupleIJNS1_12CommonFieldsEN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENS7_18DescriptorByNameEqENSt3__19allocatorIPKNS5_8internal15DescriptorTableEEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemISH_XT_EE4typeEv:
  259|     30|  ElemT<I>& get() & {
  260|     30|    return StorageT<I>::get();
  261|     30|  }
_ZNR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIPKN6google8protobuf8internal15DescriptorTableEEELm3ELb1EE3getEv:
  124|     30|  T& get() & { return *this; }
message.cc:_ZNR4absl12lts_2023012518container_internal15CompressedTupleIJNS1_12CommonFieldsEN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENS7_18DescriptorByNameEqENSt3__19allocatorIPKNS5_8internal15DescriptorTableEEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemISH_XT_EE4typeEv:
  259|    166|  ElemT<I>& get() & {
  260|    166|    return StorageT<I>::get();
  261|    166|  }
message.cc:_ZN4absl12lts_2023012518container_internal15CompressedTupleIJNS1_12CommonFieldsEN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENS7_18DescriptorByNameEqENSt3__19allocatorIPKNS5_8internal15DescriptorTableEEEEEC2IS3_JS8_S9_SG_ELb1EEEOT_DpOT0_:
  256|      2|                                             absl::forward<Vs>(base)...) {}
message.cc:_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsEN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENS9_18DescriptorByNameEqENSt3__19allocatorIPKNS7_8internal15DescriptorTableEEEEEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_SA_SB_SI_EEENS0_10in_place_tEDpOT_:
  144|      2|      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
message.cc:_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageIN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashELm1ELb1EEC2IS8_EENS0_10in_place_tEOT_:
  121|      2|      : T(absl::forward<V>(v)) {}
message.cc:_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageIN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory18DescriptorByNameEqELm2ELb1EEC2IS8_EENS0_10in_place_tEOT_:
  121|      2|      : T(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIPKN6google8protobuf8internal15DescriptorTableEEELm3ELb1EEC2ISC_EENS0_10in_place_tEOT_:
  121|      2|      : T(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_6HashEqIPKN6google8protobuf10DescriptorEvE4HashENSA_2EqENSt3__19allocatorINSD_4pairIKS9_PKNS6_7MessageEEEEEEEC2IS3_JSB_SC_SL_ELb1EEEOT_DpOT0_:
  256|      2|                                             absl::forward<Vs>(base)...) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_6HashEqIPKN6google8protobuf10DescriptorEvE4HashENSC_2EqENSt3__19allocatorINSF_4pairIKSB_PKNS8_7MessageEEEEEEEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_SD_SE_SN_EEENS0_10in_place_tEDpOT_:
  144|      2|      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS4_4pairIKPKN6google8protobuf10DescriptorEPKNS8_7MessageEEEEELm3ELb1EEC2ISH_EENS0_10in_place_tEOT_:
  121|      2|      : T(absl::forward<V>(v)) {}
message.cc:_ZNR4absl12lts_2023012518container_internal15CompressedTupleIJNS1_12CommonFieldsEN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENS7_18DescriptorByNameEqENSt3__19allocatorIPKNS5_8internal15DescriptorTableEEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISH_XT_EE4typeEv:
  259|     20|  ElemT<I>& get() & {
  260|     20|    return StorageT<I>::get();
  261|     20|  }
message.cc:_ZNR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageIN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashELm1ELb1EE3getEv:
  124|     20|  T& get() & { return *this; }
_ZN4absl12lts_2023012518container_internal15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareENS7_9FileEntryEE15checked_compareENSt3__19allocatorIS9_EEPNS1_10btree_nodeINS1_10set_paramsIS9_S8_SE_Li256ELb0EEEEEEEC2IRKSB_JRKSE_SJ_ELb1EEEOT_DpOT0_:
  256|      2|                                             absl::forward<Vs>(base)...) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareENS9_9FileEntryEE15checked_compareENSt3__19allocatorISB_EEPNS1_10btree_nodeINS1_10set_paramsISB_SA_SG_Li256ELb0EEEEEEEENS0_16integer_sequenceImJLm0ELm1ELm2EEEELb1EEC2IJRKSD_RKSG_SL_EEENS0_10in_place_tEDpOT_:
  144|      2|      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareENS8_9FileEntryEE15checked_compareELm0ELb0EEC2IRKSC_EENS0_10in_place_tEOT_:
  108|      2|      : value(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEELm1ELb1EEC2IRKSB_EENS0_10in_place_tEOT_:
  121|      2|      : T(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS9_11FileCompareENSt3__19allocatorISA_EELi256ELb0EEEEELm2ELb0EEC2ISH_EENS0_10in_place_tEOT_:
  108|      2|      : value(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS7_11SymbolEntryEE15checked_compareENSt3__19allocatorIS9_EEPNS1_10btree_nodeINS1_10set_paramsIS9_S8_SE_Li256ELb0EEEEEEEC2IRKSB_JRKSE_SJ_ELb1EEEOT_DpOT0_:
  256|      2|                                             absl::forward<Vs>(base)...) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS9_11SymbolEntryEE15checked_compareENSt3__19allocatorISB_EEPNS1_10btree_nodeINS1_10set_paramsISB_SA_SG_Li256ELb0EEEEEEEENS0_16integer_sequenceImJLm0ELm1ELm2EEEELb1EEC2IJRKSD_RKSG_SL_EEENS0_10in_place_tEDpOT_:
  144|      2|      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS8_11SymbolEntryEE15checked_compareELm0ELb0EEC2IRKSC_EENS0_10in_place_tEOT_:
  108|      2|      : value(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEELm1ELb1EEC2IRKSB_EENS0_10in_place_tEOT_:
  121|      2|      : T(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS9_13SymbolCompareENSt3__19allocatorISA_EELi256ELb0EEEEELm2ELb0EEC2ISH_EENS0_10in_place_tEOT_:
  108|      2|      : value(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex16ExtensionCompareENS7_14ExtensionEntryEE15checked_compareENSt3__19allocatorIS9_EEPNS1_10btree_nodeINS1_10set_paramsIS9_S8_SE_Li256ELb0EEEEEEEC2IRKSB_JRKSE_SJ_ELb1EEEOT_DpOT0_:
  256|      2|                                             absl::forward<Vs>(base)...) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex16ExtensionCompareENS9_14ExtensionEntryEE15checked_compareENSt3__19allocatorISB_EEPNS1_10btree_nodeINS1_10set_paramsISB_SA_SG_Li256ELb0EEEEEEEENS0_16integer_sequenceImJLm0ELm1ELm2EEEELb1EEC2IJRKSD_RKSG_SL_EEENS0_10in_place_tEDpOT_:
  144|      2|      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex16ExtensionCompareENS8_14ExtensionEntryEE15checked_compareELm0ELb0EEC2IRKSC_EENS0_10in_place_tEOT_:
  108|      2|      : value(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex14ExtensionEntryEEELm1ELb1EEC2IRKSB_EENS0_10in_place_tEOT_:
  121|      2|      : T(absl::forward<V>(v)) {}
_ZN4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex14ExtensionEntryENS9_16ExtensionCompareENSt3__19allocatorISA_EELi256ELb0EEEEELm2ELb0EEC2ISH_EENS0_10in_place_tEOT_:
  108|      2|      : value(absl::forward<V>(v)) {}
_ZNR4absl12lts_2023012518container_internal15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS7_11SymbolEntryEE15checked_compareENSt3__19allocatorIS9_EEPNS1_10btree_nodeINS1_10set_paramsIS9_S8_SE_Li256ELb0EEEEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISK_XT_EE4typeEv:
  259|    144|  ElemT<I>& get() & {
  260|    144|    return StorageT<I>::get();
  261|    144|  }
_ZNR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEELm1ELb1EE3getEv:
  124|    144|  T& get() & { return *this; }
_ZNR4absl12lts_2023012518container_internal15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS7_11SymbolEntryEE15checked_compareENSt3__19allocatorIS9_EEPNS1_10btree_nodeINS1_10set_paramsIS9_S8_SE_Li256ELb0EEEEEEE3getILi2EEERNS1_25internal_compressed_tuple4ElemISK_XT_EE4typeEv:
  259|    356|  ElemT<I>& get() & {
  260|    356|    return StorageT<I>::get();
  261|    356|  }
_ZNR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS9_13SymbolCompareENSt3__19allocatorISA_EELi256ELb0EEEEELm2ELb0EE3getEv:
  110|    356|  T& get() & { return value; }
_ZNR4absl12lts_2023012518container_internal15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareENS7_9FileEntryEE15checked_compareENSt3__19allocatorIS9_EEPNS1_10btree_nodeINS1_10set_paramsIS9_S8_SE_Li256ELb0EEEEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISK_XT_EE4typeEv:
  259|     20|  ElemT<I>& get() & {
  260|     20|    return StorageT<I>::get();
  261|     20|  }
_ZNR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEELm1ELb1EE3getEv:
  124|     20|  T& get() & { return *this; }
_ZNR4absl12lts_2023012518container_internal15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareENS7_9FileEntryEE15checked_compareENSt3__19allocatorIS9_EEPNS1_10btree_nodeINS1_10set_paramsIS9_S8_SE_Li256ELb0EEEEEEE3getILi2EEERNS1_25internal_compressed_tuple4ElemISK_XT_EE4typeEv:
  259|      8|  ElemT<I>& get() & {
  260|      8|    return StorageT<I>::get();
  261|      8|  }
_ZNR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS9_11FileCompareENSt3__19allocatorISA_EELi256ELb0EEEEELm2ELb0EE3getEv:
  110|      8|  T& get() & { return value; }
_ZNKR4absl12lts_2023012518container_internal15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareENS7_9FileEntryEE15checked_compareENSt3__19allocatorIS9_EEPNS1_10btree_nodeINS1_10set_paramsIS9_S8_SE_Li256ELb0EEEEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISK_XT_EE4typeEv:
  264|     30|  constexpr const ElemT<I>& get() const& {
  265|     30|    return StorageT<I>::get();
  266|     30|  }
_ZNKR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareENS8_9FileEntryEE15checked_compareELm0ELb0EE3getEv:
  109|     30|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2023012518container_internal15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS7_11SymbolEntryEE15checked_compareENSt3__19allocatorIS9_EEPNS1_10btree_nodeINS1_10set_paramsIS9_S8_SE_Li256ELb0EEEEEEE3getILi2EEERKNS1_25internal_compressed_tuple4ElemISK_XT_EE4typeEv:
  264|      8|  constexpr const ElemT<I>& get() const& {
  265|      8|    return StorageT<I>::get();
  266|      8|  }
_ZNKR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS9_13SymbolCompareENSt3__19allocatorISA_EELi256ELb0EEEEELm2ELb0EE3getEv:
  109|      8|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2023012518container_internal15CompressedTupleIJNS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS7_11SymbolEntryEE15checked_compareENSt3__19allocatorIS9_EEPNS1_10btree_nodeINS1_10set_paramsIS9_S8_SE_Li256ELb0EEEEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISK_XT_EE4typeEv:
  264|    408|  constexpr const ElemT<I>& get() const& {
  265|    408|    return StorageT<I>::get();
  266|    408|  }
_ZNKR4absl12lts_2023012518container_internal25internal_compressed_tuple7StorageINS1_19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS8_11SymbolEntryEE15checked_compareELm0ELb0EE3getEv:
  109|    408|  constexpr const T& get() const& { return value; }

_ZN4absl12lts_2023012518container_internal27SanitizerPoisonMemoryRegionEPKvm:
  220|    514|inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
  221|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  222|       |  ASAN_POISON_MEMORY_REGION(m, s);
  223|       |#endif
  224|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  225|       |  __msan_poison(m, s);
  226|       |#endif
  227|    514|  (void)m;
  228|    514|  (void)s;
  229|    514|}
_ZN4absl12lts_2023012518container_internal29SanitizerUnpoisonMemoryRegionEPKvm:
  231|    630|inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
  232|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  233|       |  ASAN_UNPOISON_MEMORY_REGION(m, s);
  234|       |#endif
  235|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  236|       |  __msan_unpoison(m, s);
  237|       |#endif
  238|    630|  (void)m;
  239|    630|  (void)s;
  240|    630|}
_ZN4absl12lts_2023012518container_internal8AllocateILm8ENSt3__19allocatorIcEEEEPvPT0_m:
   55|      6|void* Allocate(Alloc* alloc, size_t n) {
   56|      6|  static_assert(Alignment > 0, "");
   57|      6|  assert(n && "n must be positive");
   58|      6|  using M = AlignedType<Alignment>;
   59|      6|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   60|      6|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   61|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   62|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   63|       |  // with the "foo(bar)" syntax.
   64|      6|  A my_mem_alloc(*alloc);
   65|      6|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   66|      6|  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   67|      6|         "allocator does not respect alignment");
   68|      6|  return p;
   69|      6|}
_ZN4absl12lts_2023012518container_internal10DeallocateILm8ENSt3__19allocatorIPKN6google8protobuf8internal15DescriptorTableEEEEEvPT0_Pvm:
   74|      4|void Deallocate(Alloc* alloc, void* p, size_t n) {
   75|      4|  static_assert(Alignment > 0, "");
   76|      4|  assert(n && "n must be positive");
   77|      4|  using M = AlignedType<Alignment>;
   78|      4|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   79|      4|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   80|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   81|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   82|       |  // with the "foo(bar)" syntax.
   83|      4|  A my_mem_alloc(*alloc);
   84|      4|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
   85|      4|                 (n + sizeof(M) - 1) / sizeof(M));
   86|      4|}
message.cc:_ZN4absl12lts_2023012518container_internal14DecomposeValueINS1_12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS6_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSD_18DescriptorByNameEqENSt3__19allocatorISA_EEE19EmplaceDecomposableERKSA_EEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEclsr3stdE7declvalISO_EEEEOSN_OSO_:
  214|     12|DecomposeValue(F&& f, Arg&& arg) {
  215|     12|  const auto& key = arg;
  216|     12|  return std::forward<F>(f)(key, std::forward<Arg>(arg));
  217|     12|}
message.cc:_ZN4absl12lts_2023012518container_internal14DecomposeValueINS1_12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS6_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSD_18DescriptorByNameEqENSt3__19allocatorISA_EEE11HashElementERSA_EEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEclsr3stdE7declvalISN_EEEEOSM_OSN_:
  214|      8|DecomposeValue(F&& f, Arg&& arg) {
  215|      8|  const auto& key = arg;
  216|      8|  return std::forward<F>(f)(key, std::forward<Arg>(arg));
  217|      8|}
_ZN4absl12lts_2023012518container_internal21SanitizerPoisonObjectIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEvPKT_:
  243|    442|inline void SanitizerPoisonObject(const T* object) {
  244|    442|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  245|    442|}
_ZN4absl12lts_2023012518container_internal10DeallocateILm8ENSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEEEvPT0_Pvm:
   74|      6|void Deallocate(Alloc* alloc, void* p, size_t n) {
   75|      6|  static_assert(Alignment > 0, "");
   76|      6|  assert(n && "n must be positive");
   77|      6|  using M = AlignedType<Alignment>;
   78|      6|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   79|      6|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   80|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   81|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   82|       |  // with the "foo(bar)" syntax.
   83|      6|  A my_mem_alloc(*alloc);
   84|      6|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
   85|      6|                 (n + sizeof(M) - 1) / sizeof(M));
   86|      6|}
_ZN4absl12lts_2023012518container_internal21SanitizerPoisonObjectIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEEvPKT_:
  243|     26|inline void SanitizerPoisonObject(const T* object) {
  244|     26|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  245|     26|}
_ZN4absl12lts_2023012518container_internal10DeallocateILm8ENSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEEEEvPT0_Pvm:
   74|      6|void Deallocate(Alloc* alloc, void* p, size_t n) {
   75|      6|  static_assert(Alignment > 0, "");
   76|      6|  assert(n && "n must be positive");
   77|      6|  using M = AlignedType<Alignment>;
   78|      6|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   79|      6|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   80|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   81|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   82|       |  // with the "foo(bar)" syntax.
   83|      6|  A my_mem_alloc(*alloc);
   84|      6|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
   85|      6|                 (n + sizeof(M) - 1) / sizeof(M));
   86|      6|}
_ZN4absl12lts_2023012518container_internal8AllocateILm8ENSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEEEEPvPT0_m:
   55|      8|void* Allocate(Alloc* alloc, size_t n) {
   56|      8|  static_assert(Alignment > 0, "");
   57|      8|  assert(n && "n must be positive");
   58|      8|  using M = AlignedType<Alignment>;
   59|      8|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   60|      8|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   61|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   62|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   63|       |  // with the "foo(bar)" syntax.
   64|      8|  A my_mem_alloc(*alloc);
   65|      8|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   66|      8|  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   67|      8|         "allocator does not respect alignment");
   68|      8|  return p;
   69|      8|}
_ZN4absl12lts_2023012518container_internal23SanitizerUnpoisonObjectIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEEvPKT_:
  248|     38|inline void SanitizerUnpoisonObject(const T* object) {
  249|     38|  SanitizerUnpoisonMemoryRegion(object, sizeof(T));
  250|     38|}
_ZN4absl12lts_2023012518container_internal8AllocateILm8ENSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEEEPvPT0_m:
   55|     22|void* Allocate(Alloc* alloc, size_t n) {
   56|     22|  static_assert(Alignment > 0, "");
   57|     22|  assert(n && "n must be positive");
   58|     22|  using M = AlignedType<Alignment>;
   59|     22|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   60|     22|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   61|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   62|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   63|       |  // with the "foo(bar)" syntax.
   64|     22|  A my_mem_alloc(*alloc);
   65|     22|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   66|     22|  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   67|     22|         "allocator does not respect alignment");
   68|     22|  return p;
   69|     22|}
_ZN4absl12lts_2023012518container_internal23SanitizerUnpoisonObjectIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEvPKT_:
  248|    526|inline void SanitizerUnpoisonObject(const T* object) {
  249|    526|  SanitizerUnpoisonMemoryRegion(object, sizeof(T));
  250|    526|}
_ZN4absl12lts_2023012518container_internal21SanitizerPoisonObjectIPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEEEvPKT_:
  243|      8|inline void SanitizerPoisonObject(const T* object) {
  244|      8|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  245|      8|}
_ZN4absl12lts_2023012518container_internal23SanitizerUnpoisonObjectIPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEEEvPKT_:
  248|     30|inline void SanitizerUnpoisonObject(const T* object) {
  249|     30|  SanitizerUnpoisonMemoryRegion(object, sizeof(T));
  250|     30|}

message.cc:_ZN4absl12lts_2023012518container_internal18hash_policy_traitsINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEEvE5applyINS1_12raw_hash_setISA_NS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSF_18DescriptorByNameEqENSt3__19allocatorIS9_EEE19EmplaceDecomposableEJRKS9_ESA_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSQ_DpOSR_:
  133|     12|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  134|     12|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  135|     12|  }
message.cc:_ZN4absl12lts_2023012518container_internal18hash_policy_traitsINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEEvE5applyINS1_12raw_hash_setISA_NS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSF_18DescriptorByNameEqENSt3__19allocatorIS9_EEE11HashElementEJRS9_ESA_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSP_DpOSQ_:
  133|      8|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  134|      8|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  135|      8|  }

_ZN4absl12lts_2023012518container_internal20HashtablezInfoHandleC2EDn:
  198|      2|  explicit HashtablezInfoHandle(std::nullptr_t) {}
_ZN4absl12lts_2023012518container_internal20HashtablezInfoHandle20RecordStorageChangedEmm:
  201|      6|  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
_ZN4absl12lts_2023012518container_internal20HashtablezInfoHandle12RecordRehashEm:
  202|      6|  inline void RecordRehash(size_t /*total_probe_length*/) {}
_ZN4absl12lts_2023012518container_internal20HashtablezInfoHandle12RecordInsertEmm:
  205|     12|  inline void RecordInsert(size_t /*hash*/, size_t /*distance_from_desired*/) {}
_ZN4absl12lts_2023012518container_internal6SampleEm:
  220|      2|    size_t inline_element_size ABSL_ATTRIBUTE_UNUSED) {
  221|       |#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
  222|       |  if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0)) {
  223|       |    return HashtablezInfoHandle(nullptr);
  224|       |  }
  225|       |  return HashtablezInfoHandle(
  226|       |      SampleSlow(global_next_sample, inline_element_size));
  227|       |#else
  228|      2|  return HashtablezInfoHandle(nullptr);
  229|      2|#endif  // !ABSL_PER_THREAD_TLS
  230|      2|}

_ZN4absl12lts_2023012518container_internal15internal_layout11adl_barrier5AlignEmm:
  283|  11.8k|constexpr size_t Align(size_t n, size_t m) { return (n + m - 1) & ~(m - 1); }
_ZN4absl12lts_2023012518container_internal6LayoutIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEjhS9_SG_EEC2Emmmmm:
  736|  4.98k|      : internal_layout::LayoutType<sizeof...(Ts), Ts...>(sizes...) {}
_ZN4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_EC2Emmmmm:
  382|  4.98k|      : size_{sizes...} {}
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm2EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeEST_E4typeEPSQ_:
  475|  2.65k|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|  2.65k|    using C = typename std::remove_const<Char>::type;
  477|  2.65k|    static_assert(
  478|  2.65k|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|  2.65k|            std::is_same<C, signed char>(),
  480|  2.65k|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|  2.65k|    constexpr size_t alignment = Alignment();
  482|  2.65k|    (void)alignment;
  483|  2.65k|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|  2.65k|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|  2.65k|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E6OffsetILm2ELi0EEEmv:
  404|  4.58k|  constexpr size_t Offset() const {
  405|  4.58k|    static_assert(N < NumOffsets, "Index out of bounds");
  406|  4.58k|    return adl_barrier::Align(
  407|  4.58k|        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
  408|  4.58k|        ElementAlignment<N>::value);
  409|  4.58k|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E6OffsetILm1ELi0EEEmv:
  404|  4.58k|  constexpr size_t Offset() const {
  405|  4.58k|    static_assert(N < NumOffsets, "Index out of bounds");
  406|  4.58k|    return adl_barrier::Align(
  407|  4.58k|        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
  408|  4.58k|        ElementAlignment<N>::value);
  409|  4.58k|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E6OffsetILm0ELi0EEEmv:
  399|  4.98k|  constexpr size_t Offset() const {
  400|  4.98k|    return 0;
  401|  4.98k|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm3EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeESS_E4typeEPSP_:
  475|    658|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|    658|    using C = typename std::remove_const<Char>::type;
  477|    658|    static_assert(
  478|    658|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|    658|            std::is_same<C, signed char>(),
  480|    658|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|    658|    constexpr size_t alignment = Alignment();
  482|    658|    (void)alignment;
  483|    658|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|    658|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|    658|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E6OffsetILm3ELi0EEEmv:
  404|  1.61k|  constexpr size_t Offset() const {
  405|  1.61k|    static_assert(N < NumOffsets, "Index out of bounds");
  406|  1.61k|    return adl_barrier::Align(
  407|  1.61k|        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
  408|  1.61k|        ElementAlignment<N>::value);
  409|  1.61k|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E9AllocSizeEv:
  597|     28|  constexpr size_t AllocSize() const {
  598|     28|    static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
  599|     28|    return Offset<NumTypes - 1>() +
  600|     28|        SizeOf<ElementType<NumTypes - 1>>::value * size_[NumTypes - 1];
  601|     28|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E6OffsetILm4ELi0EEEmv:
  404|    272|  constexpr size_t Offset() const {
  405|    272|    static_assert(N < NumOffsets, "Index out of bounds");
  406|    272|    return adl_barrier::Align(
  407|    272|        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
  408|    272|        ElementAlignment<N>::value);
  409|    272|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm0EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeEST_E4typeEPSQ_:
  475|    356|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|    356|    using C = typename std::remove_const<Char>::type;
  477|    356|    static_assert(
  478|    356|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|    356|            std::is_same<C, signed char>(),
  480|    356|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|    356|    constexpr size_t alignment = Alignment();
  482|    356|    (void)alignment;
  483|    356|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|    356|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|    356|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm4EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeEST_E4typeEPSQ_:
  475|    174|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|    174|    using C = typename std::remove_const<Char>::type;
  477|    174|    static_assert(
  478|    174|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|    174|            std::is_same<C, signed char>(),
  480|    174|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|    174|    constexpr size_t alignment = Alignment();
  482|    174|    (void)alignment;
  483|    174|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|    174|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|    174|  }
_ZN4absl12lts_2023012518container_internal6LayoutIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS8_11FileCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEjhS9_SG_EEC2Emmmmm:
  736|    334|      : internal_layout::LayoutType<sizeof...(Ts), Ts...>(sizes...) {}
_ZN4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_EC2Emmmmm:
  382|    334|      : size_{sizes...} {}
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm2EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeEST_E4typeEPSQ_:
  475|    156|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|    156|    using C = typename std::remove_const<Char>::type;
  477|    156|    static_assert(
  478|    156|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|    156|            std::is_same<C, signed char>(),
  480|    156|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|    156|    constexpr size_t alignment = Alignment();
  482|    156|    (void)alignment;
  483|    156|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|    156|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|    156|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E6OffsetILm2ELi0EEEmv:
  404|    320|  constexpr size_t Offset() const {
  405|    320|    static_assert(N < NumOffsets, "Index out of bounds");
  406|    320|    return adl_barrier::Align(
  407|    320|        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
  408|    320|        ElementAlignment<N>::value);
  409|    320|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E6OffsetILm1ELi0EEEmv:
  404|    320|  constexpr size_t Offset() const {
  405|    320|    static_assert(N < NumOffsets, "Index out of bounds");
  406|    320|    return adl_barrier::Align(
  407|    320|        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
  408|    320|        ElementAlignment<N>::value);
  409|    320|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E6OffsetILm0ELi0EEEmv:
  399|    334|  constexpr size_t Offset() const {
  400|    334|    return 0;
  401|    334|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm3EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeESS_E4typeEPSP_:
  475|     68|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|     68|    using C = typename std::remove_const<Char>::type;
  477|     68|    static_assert(
  478|     68|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|     68|            std::is_same<C, signed char>(),
  480|     68|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|     68|    constexpr size_t alignment = Alignment();
  482|     68|    (void)alignment;
  483|     68|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|     68|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|     68|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E6OffsetILm3ELi0EEEmv:
  404|    108|  constexpr size_t Offset() const {
  405|    108|    static_assert(N < NumOffsets, "Index out of bounds");
  406|    108|    return adl_barrier::Align(
  407|    108|        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
  408|    108|        ElementAlignment<N>::value);
  409|    108|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E9AllocSizeEv:
  597|     14|  constexpr size_t AllocSize() const {
  598|     14|    static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
  599|     14|    return Offset<NumTypes - 1>() +
  600|     14|        SizeOf<ElementType<NumTypes - 1>>::value * size_[NumTypes - 1];
  601|     14|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E6OffsetILm4ELi0EEEmv:
  404|     14|  constexpr size_t Offset() const {
  405|     14|    static_assert(N < NumOffsets, "Index out of bounds");
  406|     14|    return adl_barrier::Align(
  407|     14|        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
  408|     14|        ElementAlignment<N>::value);
  409|     14|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm0EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeEST_E4typeEPSQ_:
  475|      6|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|      6|    using C = typename std::remove_const<Char>::type;
  477|      6|    static_assert(
  478|      6|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|      6|            std::is_same<C, signed char>(),
  480|      6|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|      6|    constexpr size_t alignment = Alignment();
  482|      6|    (void)alignment;
  483|      6|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|      6|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|      6|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm0EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeESS_E4typeEPSP_:
  475|      8|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|      8|    using C = typename std::remove_const<Char>::type;
  477|      8|    static_assert(
  478|      8|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|      8|            std::is_same<C, signed char>(),
  480|      8|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|      8|    constexpr size_t alignment = Alignment();
  482|      8|    (void)alignment;
  483|      8|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|      8|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|      8|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm2EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeESS_E4typeEPSP_:
  475|     56|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|     56|    using C = typename std::remove_const<Char>::type;
  477|     56|    static_assert(
  478|     56|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|     56|            std::is_same<C, signed char>(),
  480|     56|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|     56|    constexpr size_t alignment = Alignment();
  482|     56|    (void)alignment;
  483|     56|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|     56|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|     56|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENSB_11FileCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm3EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeEST_E4typeEPSQ_:
  475|     26|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|     26|    using C = typename std::remove_const<Char>::type;
  477|     26|    static_assert(
  478|     26|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|     26|            std::is_same<C, signed char>(),
  480|     26|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|     26|    constexpr size_t alignment = Alignment();
  482|     26|    (void)alignment;
  483|     26|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|     26|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|     26|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm3EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeEST_E4typeEPSQ_:
  475|    688|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|    688|    using C = typename std::remove_const<Char>::type;
  477|    688|    static_assert(
  478|    688|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|    688|            std::is_same<C, signed char>(),
  480|    688|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|    688|    constexpr size_t alignment = Alignment();
  482|    688|    (void)alignment;
  483|    688|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|    688|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|    688|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm0EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeESS_E4typeEPSP_:
  475|     36|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|     36|    using C = typename std::remove_const<Char>::type;
  477|     36|    static_assert(
  478|     36|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|     36|            std::is_same<C, signed char>(),
  480|     36|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|     36|    constexpr size_t alignment = Alignment();
  482|     36|    (void)alignment;
  483|     36|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|     36|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|     36|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm2EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeESS_E4typeEPSP_:
  475|    316|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|    316|    using C = typename std::remove_const<Char>::type;
  477|    316|    static_assert(
  478|    316|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|    316|            std::is_same<C, signed char>(),
  480|    316|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|    316|    constexpr size_t alignment = Alignment();
  482|    316|    (void)alignment;
  483|    316|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|    316|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|    316|  }
_ZNK4absl12lts_2023012518container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENSB_13SymbolCompareENS4_9allocatorISC_EELi256ELb0EEEEEjhSC_SI_EEENS0_16integer_sequenceImJLm0ELm1ELm2ELm3ELm4EEEESL_E7PointerILm4EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESJ_E4typeESS_E4typeEPSP_:
  475|     70|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  476|     70|    using C = typename std::remove_const<Char>::type;
  477|     70|    static_assert(
  478|     70|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  479|     70|            std::is_same<C, signed char>(),
  480|     70|        "The argument must be a pointer to [const] [signed|unsigned] char");
  481|     70|    constexpr size_t alignment = Alignment();
  482|     70|    (void)alignment;
  483|     70|    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  484|     70|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  485|     70|  }

_ZN4absl12lts_2023012518container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIPKN6google8protobuf10DescriptorEPKNS5_7MessageEEENS1_6HashEqIS8_vE4HashENSE_2EqENSt3__19allocatorINSH_4pairIKS8_SB_EEEEEC2Ev:
   62|      2|  raw_hash_map() {}

_ZN4absl12lts_2023012518container_internal13GroupSse2ImplC2EPKNS1_6ctrl_tE:
  572|     38|  explicit GroupSse2Impl(const ctrl_t* pos) {
  573|     38|    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
  574|     38|  }
_ZNK4absl12lts_2023012518container_internal13GroupSse2Impl5MatchEh:
  577|     12|  BitMask<uint32_t, kWidth> Match(h2_t hash) const {
  578|     12|    auto match = _mm_set1_epi8(static_cast<char>(hash));
  579|     12|    return BitMask<uint32_t, kWidth>(
  580|     12|        static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  581|     12|  }
_ZNK4absl12lts_2023012518container_internal13GroupSse2Impl9MaskEmptyEv:
  584|     12|  NonIterableBitMask<uint32_t, kWidth> MaskEmpty() const {
  585|       |#ifdef ABSL_INTERNAL_HAVE_SSSE3
  586|       |    // This only works because ctrl_t::kEmpty is -128.
  587|       |    return NonIterableBitMask<uint32_t, kWidth>(
  588|       |        static_cast<uint32_t>(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl))));
  589|       |#else
  590|     12|    auto match = _mm_set1_epi8(static_cast<char>(ctrl_t::kEmpty));
  591|     12|    return NonIterableBitMask<uint32_t, kWidth>(
  592|     12|        static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  593|     12|#endif
  594|     12|  }
_ZNK4absl12lts_2023012518container_internal13GroupSse2Impl18MaskEmptyOrDeletedEv:
  597|     26|  NonIterableBitMask<uint32_t, kWidth> MaskEmptyOrDeleted() const {
  598|     26|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  599|     26|    return NonIterableBitMask<uint32_t, kWidth>(static_cast<uint32_t>(
  600|     26|        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))));
  601|     26|  }
_ZNK4absl12lts_2023012518container_internal34CommonFieldsGenerationInfoDisabled41should_rehash_for_bug_detection_on_insertEv:
  823|     12|  bool should_rehash_for_bug_detection_on_insert() const { return false; }
_ZN4absl12lts_2023012518container_internal34CommonFieldsGenerationInfoDisabled36maybe_increment_generation_on_insertEv:
  824|     12|  void maybe_increment_generation_on_insert() {}
_ZNK4absl12lts_2023012518container_internal34CommonFieldsGenerationInfoDisabled10generationEv:
  828|      6|  GenerationType generation() const { return 0; }
_ZN4absl12lts_2023012518container_internal34CommonFieldsGenerationInfoDisabled14set_generationEh:
  829|      6|  void set_generation(GenerationType) {}
_ZNK4absl12lts_2023012518container_internal34CommonFieldsGenerationInfoDisabled14generation_ptrEv:
  830|     12|  GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2023012518container_internal34CommonFieldsGenerationInfoDisabled18set_generation_ptrEPh:
  831|      6|  void set_generation_ptr(GenerationType*) {}
_ZN4absl12lts_2023012518container_internal37HashSetIteratorGenerationInfoDisabledC2EPKh:
  854|     12|  explicit HashSetIteratorGenerationInfoDisabled(const GenerationType*) {}
_ZN4absl12lts_2023012518container_internal12CommonFieldsC2EOS2_:
  891|      4|        compressed_tuple_(that.growth_left(), std::move(that.infoz())) {
  892|      4|    that.control_ = EmptyGroup();
  893|      4|    that.slots_ = nullptr;
  894|      4|    that.size_ = 0;
  895|      4|    that.capacity_ = 0;
  896|      4|    that.growth_left() = 0;
  897|      4|  }
_ZN4absl12lts_2023012518container_internal12CommonFields11growth_leftEv:
  901|     38|  size_t& growth_left() { return compressed_tuple_.template get<0>(); }
_ZN4absl12lts_2023012518container_internal12CommonFields5infozEv:
  903|     30|  HashtablezInfoHandle& infoz() { return compressed_tuple_.template get<1>(); }
_ZN4absl12lts_2023012518container_internal18NumGenerationBytesEv:
  243|     16|constexpr size_t NumGenerationBytes() { return 0; }
_ZN4absl12lts_2023012518container_internal10EmptyGroupEv:
  481|      8|inline ctrl_t* EmptyGroup() {
  482|       |  // Const must be cast away here; no uses of this function will actually write
  483|       |  // to it, because it is only used for empty tables.
  484|      8|  return const_cast<ctrl_t*>(kEmptyGroup);
  485|      8|}
_ZN4absl12lts_2023012518container_internal12PerTableSaltEPKNS1_6ctrl_tE:
  502|     38|inline size_t PerTableSalt(const ctrl_t* ctrl) {
  503|       |  // The low bits of the pointer have little or no entropy because of
  504|       |  // alignment. We shift the pointer to try to use higher entropy bits. A
  505|       |  // good number seems to be 12 bits, because that aligns with page size.
  506|     38|  return reinterpret_cast<uintptr_t>(ctrl) >> 12;
  507|     38|}
_ZN4absl12lts_2023012518container_internal2H1EmPKNS1_6ctrl_tE:
  509|     38|inline size_t H1(size_t hash, const ctrl_t* ctrl) {
  510|     38|  return (hash >> 7) ^ PerTableSalt(ctrl);
  511|     38|}
_ZN4absl12lts_2023012518container_internal2H2Em:
  516|     32|inline h2_t H2(size_t hash) { return hash & 0x7F; }
_ZN4absl12lts_2023012518container_internal7IsEmptyENS1_6ctrl_tE:
  519|     12|inline bool IsEmpty(ctrl_t c) { return c == ctrl_t::kEmpty; }
_ZN4absl12lts_2023012518container_internal6IsFullENS1_6ctrl_tE:
  520|     28|inline bool IsFull(ctrl_t c) { return c >= static_cast<ctrl_t>(0); }
_ZN4absl12lts_2023012518container_internal9IsDeletedENS1_6ctrl_tE:
  521|      6|inline bool IsDeleted(ctrl_t c) { return c == ctrl_t::kDeleted; }
_ZN4absl12lts_2023012518container_internal20_mm_cmpgt_epi8_fixedEDv2_xS2_:
  558|     26|inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
  559|       |#if defined(__GNUC__) && !defined(__clang__)
  560|       |  if (std::is_unsigned<char>::value) {
  561|       |    const __m128i mask = _mm_set1_epi8(0x80);
  562|       |    const __m128i diff = _mm_subs_epi8(b, a);
  563|       |    return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
  564|       |  }
  565|       |#endif
  566|     26|  return _mm_cmpgt_epi8(a, b);
  567|     26|}
_ZN4absl12lts_2023012518container_internal14NumClonedBytesEv:
  943|     68|constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
_ZN4absl12lts_2023012518container_internal12NextCapacityEm:
  954|      6|inline size_t NextCapacity(size_t n) {
  955|      6|  assert(IsValidCapacity(n) || n == 0);
  956|      6|  return n * 2 + 1;
  957|      6|}
_ZN4absl12lts_2023012518container_internal16CapacityToGrowthEm:
  984|      6|inline size_t CapacityToGrowth(size_t capacity) {
  985|      6|  assert(IsValidCapacity(capacity));
  986|       |  // `capacity*7/8`
  987|      6|  if (Group::kWidth == 8 && capacity == 7) {
  ------------------
  |  Branch (987:7): [Folded - Ignored]
  |  Branch (987:29): [True: 0, False: 0]
  ------------------
  988|       |    // x-x/8 does not work when x==7.
  989|      0|    return 6;
  990|      0|  }
  991|      6|  return capacity - capacity / 8;
  992|      6|}
_ZN4absl12lts_2023012518container_internal5probeERKNS1_12CommonFieldsEm:
 1109|     38|inline probe_seq<Group::kWidth> probe(const CommonFields& common, size_t hash) {
 1110|     38|  const ctrl_t* ctrl = common.control_;
 1111|     38|  const size_t capacity = common.capacity_;
 1112|     38|  return probe_seq<Group::kWidth>(H1(hash, ctrl), capacity);
 1113|     38|}
_ZN4absl12lts_2023012518container_internal15ResetGrowthLeftERNS1_12CommonFieldsE:
 1155|      6|inline void ResetGrowthLeft(CommonFields& common) {
 1156|      6|  common.growth_left() = CapacityToGrowth(common.capacity_) - common.size_;
 1157|      6|}
_ZN4absl12lts_2023012518container_internal9ResetCtrlERNS1_12CommonFieldsEm:
 1161|      6|inline void ResetCtrl(CommonFields& common, size_t slot_size) {
 1162|      6|  const size_t capacity = common.capacity_;
 1163|      6|  ctrl_t* ctrl = common.control_;
 1164|      6|  std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty),
 1165|      6|              capacity + 1 + NumClonedBytes());
 1166|      6|  ctrl[capacity] = ctrl_t::kSentinel;
 1167|      6|  SanitizerPoisonMemoryRegion(common.slots_, slot_size * capacity);
 1168|      6|  ResetGrowthLeft(common);
 1169|      6|}
_ZN4absl12lts_2023012518container_internal7SetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
 1176|     20|                    size_t slot_size) {
 1177|     20|  const size_t capacity = common.capacity_;
 1178|     20|  assert(i < capacity);
 1179|       |
 1180|     20|  auto* slot_i = static_cast<const char*>(common.slots_) + i * slot_size;
 1181|     20|  if (IsFull(h)) {
  ------------------
  |  Branch (1181:7): [True: 20, False: 0]
  ------------------
 1182|     20|    SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
 1183|     20|  } else {
 1184|      0|    SanitizerPoisonMemoryRegion(slot_i, slot_size);
 1185|      0|  }
 1186|       |
 1187|     20|  ctrl_t* ctrl = common.control_;
 1188|     20|  ctrl[i] = h;
 1189|     20|  ctrl[((i - NumClonedBytes()) & capacity) + (NumClonedBytes() & capacity)] = h;
 1190|     20|}
_ZN4absl12lts_2023012518container_internal7SetCtrlERKNS1_12CommonFieldsEmhm:
 1194|     20|                    size_t slot_size) {
 1195|     20|  SetCtrl(common, i, static_cast<ctrl_t>(h), slot_size);
 1196|     20|}
_ZN4absl12lts_2023012518container_internal16GenerationOffsetEm:
 1200|      6|inline size_t GenerationOffset(size_t capacity) {
 1201|      6|  assert(IsValidCapacity(capacity));
 1202|      6|  const size_t num_control_bytes = capacity + 1 + NumClonedBytes();
 1203|      6|  return num_control_bytes;
 1204|      6|}
_ZN4absl12lts_2023012518container_internal10SlotOffsetEmm:
 1208|     16|inline size_t SlotOffset(size_t capacity, size_t slot_align) {
 1209|     16|  assert(IsValidCapacity(capacity));
 1210|     16|  const size_t num_control_bytes = capacity + 1 + NumClonedBytes();
 1211|     16|  return (num_control_bytes + NumGenerationBytes() + slot_align - 1) &
 1212|     16|         (~slot_align + 1);
 1213|     16|}
_ZN4absl12lts_2023012518container_internal9AllocSizeEmmm:
 1217|     10|inline size_t AllocSize(size_t capacity, size_t slot_size, size_t slot_align) {
 1218|     10|  return SlotOffset(capacity, slot_align) + capacity * slot_size;
 1219|     10|}
_ZN4absl12lts_2023012518container_internal13TrailingZerosIjEEjT_:
  339|     26|uint32_t TrailingZeros(T x) {
  340|     26|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  258|     26|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  341|     26|  return static_cast<uint32_t>(countr_zero(x));
  342|     26|}
_ZNK4absl12lts_2023012518container_internal9probe_seqILm16EE6offsetEv:
  290|     38|  size_t offset() const { return offset_; }
_ZNK4absl12lts_2023012518container_internal7BitMaskIjLi16ELi0EE5beginEv:
  415|     12|  BitMask begin() const { return *this; }
_ZNK4absl12lts_2023012518container_internal7BitMaskIjLi16ELi0EE3endEv:
  416|     12|  BitMask end() const { return BitMask(0); }
_ZN4absl12lts_2023012518container_internalneERKNS1_7BitMaskIjLi16ELi0EEES5_:
  422|     12|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  423|     12|    return a.mask_ != b.mask_;
  424|     12|  }
_ZNK4absl12lts_2023012518container_internal18NonIterableBitMaskIjLi16ELi0EE12LowestBitSetEv:
  361|     26|  uint32_t LowestBitSet() const {
  362|     26|    return container_internal::TrailingZeros(mask_) >> Shift;
  363|     26|  }
_ZNK4absl12lts_2023012518container_internal9probe_seqILm16EE6offsetEm:
  291|     26|  size_t offset(size_t i) const { return (offset_ + i) & mask_; }
_ZNK4absl12lts_2023012518container_internal18NonIterableBitMaskIjLi16ELi0EEcvbEv:
  358|     38|  explicit operator bool() const { return this->mask_ != 0; }
_ZN4absl12lts_2023012518container_internal12CommonFieldsC2Ev:
  875|      4|  CommonFields() = default;
_ZN4absl12lts_2023012518container_internal9probe_seqILm16EEC2Emm:
  283|     38|  probe_seq(size_t hash, size_t mask) {
  284|     38|    assert(((mask + 1) & mask) == 0 && "not a mask");
  285|     38|    mask_ = mask;
  286|     38|    offset_ = hash & mask_;
  287|     38|  }
_ZN4absl12lts_2023012518container_internal7BitMaskIjLi16ELi0EEC2Ej:
  402|     24|  explicit BitMask(T mask) : Base(mask) {}
_ZN4absl12lts_2023012518container_internal18NonIterableBitMaskIjLi16ELi0EEC2Ej:
  356|     62|  explicit NonIterableBitMask(T mask) : mask_(mask) {}
_ZN4absl12lts_2023012518container_internal19find_first_non_fullIvEENS1_8FindInfoERKNS1_12CommonFieldsEm:
 1123|     26|inline FindInfo find_first_non_full(const CommonFields& common, size_t hash) {
 1124|     26|  auto seq = probe(common, hash);
 1125|     26|  const ctrl_t* ctrl = common.control_;
 1126|     26|  while (true) {
  ------------------
  |  Branch (1126:10): [Folded - Ignored]
  ------------------
 1127|     26|    Group g{ctrl + seq.offset()};
 1128|     26|    auto mask = g.MaskEmptyOrDeleted();
 1129|     26|    if (mask) {
  ------------------
  |  Branch (1129:9): [True: 26, False: 0]
  ------------------
 1130|       |#if !defined(NDEBUG)
 1131|       |      // We want to add entropy even when ASLR is not enabled.
 1132|       |      // In debug build we will randomly insert in either the front or back of
 1133|       |      // the group.
 1134|       |      // TODO(kfm,sbenza): revisit after we do unconditional mixing
 1135|       |      if (!is_small(common.capacity_) && ShouldInsertBackwards(hash, ctrl)) {
 1136|       |        return {seq.offset(mask.HighestBitSet()), seq.index()};
 1137|       |      }
 1138|       |#endif
 1139|     26|      return {seq.offset(mask.LowestBitSet()), seq.index()};
 1140|     26|    }
 1141|      0|    seq.next();
 1142|      0|    assert(seq.index() <= common.capacity_ && "full table!");
 1143|      0|  }
 1144|     26|}
_ZNK4absl12lts_2023012518container_internal9probe_seqILm16EE5indexEv:
  299|     26|  size_t index() const { return index_; }
_ZN4absl12lts_2023012518container_internal15InitializeSlotsINSt3__19allocatorIcEELm8ELm8EEEvRNS1_12CommonFieldsET_:
 1222|      6|ABSL_ATTRIBUTE_NOINLINE void InitializeSlots(CommonFields& c, Alloc alloc) {
 1223|      6|  assert(c.capacity_);
 1224|       |  // Folks with custom allocators often make unwarranted assumptions about the
 1225|       |  // behavior of their classes vis-a-vis trivial destructability and what
 1226|       |  // calls they will or won't make.  Avoid sampling for people with custom
 1227|       |  // allocators to get us out of this mess.  This is not a hard guarantee but
 1228|       |  // a workaround while we plan the exact guarantee we want to provide.
 1229|      6|  const size_t sample_size =
 1230|      6|      (std::is_same<Alloc, std::allocator<char>>::value && c.slots_ == nullptr)
  ------------------
  |  Branch (1230:8): [Folded - Ignored]
  |  Branch (1230:60): [True: 2, False: 4]
  ------------------
 1231|      6|          ? SizeOfSlot
 1232|      6|          : 0;
 1233|       |
 1234|      6|  const size_t cap = c.capacity_;
 1235|      6|  char* mem = static_cast<char*>(
 1236|      6|      Allocate<AlignOfSlot>(&alloc, AllocSize(cap, SizeOfSlot, AlignOfSlot)));
 1237|      6|  const GenerationType old_generation = c.generation();
 1238|      6|  c.set_generation_ptr(
 1239|      6|      reinterpret_cast<GenerationType*>(mem + GenerationOffset(cap)));
 1240|      6|  c.set_generation(old_generation + 1);
 1241|      6|  c.control_ = reinterpret_cast<ctrl_t*>(mem);
 1242|      6|  c.slots_ = mem + SlotOffset(cap, AlignOfSlot);
 1243|      6|  ResetCtrl(c, SizeOfSlot);
 1244|      6|  if (sample_size) {
  ------------------
  |  Branch (1244:7): [True: 2, False: 4]
  ------------------
 1245|      2|    c.infoz() = Sample(sample_size);
 1246|      2|  }
 1247|      6|  c.infoz().RecordStorageChanged(c.size_, cap);
 1248|      6|}
message.cc:_ZNK4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE8capacityEv:
 1740|      6|  size_t capacity() const { return common().capacity_; }
message.cc:_ZNK4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE6commonEv:
 2538|    102|  const CommonFields& common() const { return settings_.template get<0>(); }
message.cc:_ZNK4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE10slot_arrayEv:
 2541|     36|  slot_type* slot_array() const {
 2542|     36|    return static_cast<slot_type*>(common().slots_);
 2543|     36|  }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE9alloc_refEv:
 2550|     30|  allocator_type& alloc_ref() { return settings_.template get<3>(); }
message.cc:_ZNK4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE7controlEv:
 2540|     60|  ctrl_t* control() const { return common().control_; }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE5infozEv:
 2544|     18|  HashtablezInfoHandle& infoz() { return common().infoz(); }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE6commonEv:
 2537|    166|  CommonFields& common() { return settings_.template get<0>(); }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEEC2Ev:
 1542|      2|              std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN6google8protobuf10DescriptorEPKNS5_7MessageEEENS1_6HashEqIS8_vE4HashENSE_2EqENSt3__19allocatorINSH_4pairIKS8_SB_EEEEEC2Ev:
 1542|      2|              std::is_nothrow_default_constructible<allocator_type>::value) {}
message.cc:_ZNK4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE19prefetch_heap_blockEv:
 2535|     12|  void prefetch_heap_block() const { base_internal::PrefetchT2(control()); }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE11iterator_atEm:
 2510|     12|  iterator iterator_at(size_t i) {
 2511|     12|    return {control() + i, slot_array() + i, common().generation_ptr()};
 2512|     12|  }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE8iteratorC2EPNS1_6ctrl_tEPS9_PKh:
 1465|     12|          slot_(slot) {
 1466|       |      // This assumption helps the compiler know that any non-end iterator is
 1467|       |      // not equal to any end iterator.
 1468|     12|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  258|     12|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1469|     12|    }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE8hash_refEv:
 2546|     20|  hasher& hash_ref() { return settings_.template get<1>(); }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE6insertIS9_Li0ELi0EEENSF_4pairINSI_8iteratorEbEERKT_:
 1804|     12|  std::pair<iterator, bool> insert(const T& value) {
 1805|     12|    return emplace(value);
 1806|     12|  }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE7emplaceIJRKS9_ELi0EEENSF_4pairINSI_8iteratorEbEEDpOT_:
 1885|     12|  std::pair<iterator, bool> emplace(Args&&... args) {
 1886|     12|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 1887|     12|                               std::forward<Args>(args)...);
 1888|     12|  }
message.cc:_ZNK4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE19EmplaceDecomposableclIS9_JRKS9_EEENSF_4pairINSI_8iteratorEbEERKT_DpOT0_:
 2261|     12|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 2262|     12|      auto res = s.find_or_prepare_insert(key);
 2263|     12|      if (res.second) {
  ------------------
  |  Branch (2263:11): [True: 12, False: 0]
  ------------------
 2264|     12|        s.emplace_at(res.first, std::forward<Args>(args)...);
 2265|     12|      }
 2266|     12|      return {s.iterator_at(res.first), res.second};
 2267|     12|    }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE22find_or_prepare_insertIS9_EENSF_4pairImbEERKT_:
 2445|     12|  std::pair<size_t, bool> find_or_prepare_insert(const K& key) {
 2446|     12|    prefetch_heap_block();
 2447|     12|    auto hash = hash_ref()(key);
 2448|     12|    auto seq = probe(common(), hash);
 2449|     12|    const ctrl_t* ctrl = control();
 2450|     12|    while (true) {
  ------------------
  |  Branch (2450:12): [Folded - Ignored]
  ------------------
 2451|     12|      Group g{ctrl + seq.offset()};
 2452|     12|      for (uint32_t i : g.Match(H2(hash))) {
  ------------------
  |  Branch (2452:23): [True: 0, False: 12]
  ------------------
 2453|      0|        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (178:30): [True: 0, False: 0]
  |  |  |  Branch (178:48): [Folded - Ignored]
  |  |  |  Branch (178:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2454|      0|                EqualElement<K>{key, eq_ref()},
 2455|      0|                PolicyTraits::element(slot_array() + seq.offset(i)))))
 2456|      0|          return {seq.offset(i), false};
 2457|      0|      }
 2458|     12|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) break;
  ------------------
  |  |  178|     12|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (178:30): [True: 12, False: 0]
  |  |  |  Branch (178:48): [Folded - Ignored]
  |  |  |  Branch (178:57): [True: 12, False: 0]
  |  |  ------------------
  ------------------
 2459|      0|      seq.next();
 2460|      0|      assert(seq.index() <= capacity() && "full table!");
 2461|      0|    }
 2462|     12|    return {prepare_insert(hash), true};
 2463|     12|  }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE14prepare_insertEm:
 2469|     12|  size_t prepare_insert(size_t hash) ABSL_ATTRIBUTE_NOINLINE {
 2470|     12|    const bool rehash_for_bug_detection =
 2471|     12|        common().should_rehash_for_bug_detection_on_insert();
 2472|     12|    if (rehash_for_bug_detection) {
  ------------------
  |  Branch (2472:9): [True: 0, False: 12]
  ------------------
 2473|       |      // Move to a different heap allocation in order to detect bugs.
 2474|      0|      const size_t cap = capacity();
 2475|      0|      resize(growth_left() > 0 ? cap : NextCapacity(cap));
  ------------------
  |  Branch (2475:14): [True: 0, False: 0]
  ------------------
 2476|      0|    }
 2477|     12|    auto target = find_first_non_full(common(), hash);
 2478|     12|    if (!rehash_for_bug_detection &&
  ------------------
  |  Branch (2478:9): [True: 12, False: 0]
  ------------------
 2479|     12|        ABSL_PREDICT_FALSE(growth_left() == 0 &&
  ------------------
  |  |  177|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (177:31): [True: 6, False: 6]
  |  |  |  Branch (177:49): [Folded - Ignored]
  |  |  |  Branch (177:59): [True: 6, False: 6]
  |  |  |  Branch (177:59): [True: 6, False: 0]
  |  |  ------------------
  ------------------
 2480|     12|                           !IsDeleted(control()[target.offset]))) {
 2481|      6|      rehash_and_grow_if_necessary();
 2482|      6|      target = find_first_non_full(common(), hash);
 2483|      6|    }
 2484|     12|    ++common().size_;
 2485|     12|    growth_left() -= IsEmpty(control()[target.offset]);
 2486|     12|    SetCtrl(common(), target.offset, H2(hash), sizeof(slot_type));
 2487|     12|    common().maybe_increment_generation_on_insert();
 2488|     12|    infoz().RecordInsert(hash, target.probe_length);
 2489|     12|    return target.offset;
 2490|     12|  }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE6resizeEm:
 2312|      6|  ABSL_ATTRIBUTE_NOINLINE void resize(size_t new_capacity) {
 2313|      6|    assert(IsValidCapacity(new_capacity));
 2314|      6|    auto* old_ctrl = control();
 2315|      6|    auto* old_slots = slot_array();
 2316|      6|    const size_t old_capacity = common().capacity_;
 2317|      6|    common().capacity_ = new_capacity;
 2318|      6|    initialize_slots();
 2319|       |
 2320|      6|    auto* new_slots = slot_array();
 2321|      6|    size_t total_probe_length = 0;
 2322|     14|    for (size_t i = 0; i != old_capacity; ++i) {
  ------------------
  |  Branch (2322:24): [True: 8, False: 6]
  ------------------
 2323|      8|      if (IsFull(old_ctrl[i])) {
  ------------------
  |  Branch (2323:11): [True: 8, False: 0]
  ------------------
 2324|      8|        size_t hash = PolicyTraits::apply(HashElement{hash_ref()},
 2325|      8|                                          PolicyTraits::element(old_slots + i));
 2326|      8|        auto target = find_first_non_full(common(), hash);
 2327|      8|        size_t new_i = target.offset;
 2328|      8|        total_probe_length += target.probe_length;
 2329|      8|        SetCtrl(common(), new_i, H2(hash), sizeof(slot_type));
 2330|      8|        PolicyTraits::transfer(&alloc_ref(), new_slots + new_i, old_slots + i);
 2331|      8|      }
 2332|      8|    }
 2333|      6|    if (old_capacity) {
  ------------------
  |  Branch (2333:9): [True: 4, False: 2]
  ------------------
 2334|      4|      SanitizerUnpoisonMemoryRegion(old_slots,
 2335|      4|                                    sizeof(slot_type) * old_capacity);
 2336|      4|      Deallocate<alignof(slot_type)>(
 2337|      4|          &alloc_ref(), old_ctrl,
 2338|      4|          AllocSize(old_capacity, sizeof(slot_type), alignof(slot_type)));
 2339|      4|    }
 2340|      6|    infoz().RecordRehash(total_probe_length);
 2341|      6|  }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE16initialize_slotsEv:
 2302|      6|  inline void initialize_slots() {
 2303|       |    // People are often sloppy with the exact type of their allocator (sometimes
 2304|       |    // it has an extra const or is missing the pair, but rebinds made it work
 2305|       |    // anyway).
 2306|      6|    using CharAlloc =
 2307|      6|        typename absl::allocator_traits<Alloc>::template rebind_alloc<char>;
 2308|      6|    InitializeSlots<CharAlloc, sizeof(slot_type), alignof(slot_type)>(
 2309|      6|        common(), CharAlloc(alloc_ref()));
 2310|      6|  }
message.cc:_ZNK4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE11HashElementclIS9_JRS9_EEEmRKT_DpOT0_:
 2243|      8|    size_t operator()(const K& key, Args&&...) const {
 2244|      8|      return h(key);
 2245|      8|    }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE11growth_leftEv:
 2530|     24|  size_t& growth_left() { return common().growth_left(); }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE28rehash_and_grow_if_necessaryEv:
 2357|      6|  void rehash_and_grow_if_necessary() {
 2358|      6|    const size_t cap = capacity();
 2359|      6|    if (cap > Group::kWidth &&
  ------------------
  |  Branch (2359:9): [True: 0, False: 6]
  ------------------
 2360|       |        // Do these calcuations in 64-bit to avoid overflow.
 2361|      6|        size() * uint64_t{32} <= cap* uint64_t{25}) {
  ------------------
  |  Branch (2361:9): [True: 0, False: 0]
  ------------------
 2362|       |      // Squash DELETED without growing if there is enough capacity.
 2363|       |      //
 2364|       |      // Rehash in place if the current size is <= 25/32 of capacity.
 2365|       |      // Rationale for such a high factor: 1) drop_deletes_without_resize() is
 2366|       |      // faster than resize, and 2) it takes quite a bit of work to add
 2367|       |      // tombstones.  In the worst case, seems to take approximately 4
 2368|       |      // insert/erase pairs to create a single tombstone and so if we are
 2369|       |      // rehashing because of tombstones, we can afford to rehash-in-place as
 2370|       |      // long as we are reclaiming at least 1/8 the capacity without doing more
 2371|       |      // than 2X the work.  (Where "work" is defined to be size() for rehashing
 2372|       |      // or rehashing in place, and 1 for an insert or erase.)  But rehashing in
 2373|       |      // place is faster per operation than inserting or even doubling the size
 2374|       |      // of the table, so we actually afford to reclaim even less space from a
 2375|       |      // resize-in-place.  The decision is to rehash in place if we can reclaim
 2376|       |      // at about 1/8th of the usable capacity (specifically 3/28 of the
 2377|       |      // capacity) which means that the total cost of rehashing will be a small
 2378|       |      // fraction of the total work.
 2379|       |      //
 2380|       |      // Here is output of an experiment using the BM_CacheInSteadyState
 2381|       |      // benchmark running the old case (where we rehash-in-place only if we can
 2382|       |      // reclaim at least 7/16*capacity) vs. this code (which rehashes in place
 2383|       |      // if we can recover 3/32*capacity).
 2384|       |      //
 2385|       |      // Note that although in the worst-case number of rehashes jumped up from
 2386|       |      // 15 to 190, but the number of operations per second is almost the same.
 2387|       |      //
 2388|       |      // Abridged output of running BM_CacheInSteadyState benchmark from
 2389|       |      // raw_hash_set_benchmark.   N is the number of insert/erase operations.
 2390|       |      //
 2391|       |      //      | OLD (recover >= 7/16        | NEW (recover >= 3/32)
 2392|       |      // size |    N/s LoadFactor NRehashes |    N/s LoadFactor NRehashes
 2393|       |      //  448 | 145284       0.44        18 | 140118       0.44        19
 2394|       |      //  493 | 152546       0.24        11 | 151417       0.48        28
 2395|       |      //  538 | 151439       0.26        11 | 151152       0.53        38
 2396|       |      //  583 | 151765       0.28        11 | 150572       0.57        50
 2397|       |      //  628 | 150241       0.31        11 | 150853       0.61        66
 2398|       |      //  672 | 149602       0.33        12 | 150110       0.66        90
 2399|       |      //  717 | 149998       0.35        12 | 149531       0.70       129
 2400|       |      //  762 | 149836       0.37        13 | 148559       0.74       190
 2401|       |      //  807 | 149736       0.39        14 | 151107       0.39        14
 2402|       |      //  852 | 150204       0.42        15 | 151019       0.42        15
 2403|      0|      drop_deletes_without_resize();
 2404|      6|    } else {
 2405|       |      // Otherwise grow the container.
 2406|      6|      resize(NextCapacity(cap));
 2407|      6|    }
 2408|      6|  }
message.cc:_ZN4absl12lts_2023012518container_internal12raw_hash_setINS1_17FlatHashSetPolicyIPKN6google8protobuf8internal15DescriptorTableEEENS5_12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashENSC_18DescriptorByNameEqENSt3__19allocatorIS9_EEE10emplace_atIJRKS9_EEEvmDpOT_:
 2501|     12|  void emplace_at(size_t i, Args&&... args) {
 2502|     12|    PolicyTraits::construct(&alloc_ref(), slot_array() + i,
 2503|     12|                            std::forward<Args>(args)...);
 2504|       |
 2505|     12|    assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) ==
 2506|     12|               iterator_at(i) &&
 2507|     12|           "constructed value does not match the lookup key");
 2508|     12|  }

_ZN4absl12lts_202301256HashOfIJEJNS0_11string_viewEEEEmDpRKT0_:
  264|     20|size_t HashOf(const Types&... values) {
  265|     20|  auto tuple = std::tie(values...);
  266|     20|  return absl::Hash<decltype(tuple)>{}(tuple);
  267|     20|}

_ZN4absl12lts_2023012513hash_internal15MixingHashState16LowLevelHashImplEPKhm:
   63|     20|                                           size_t len) {
   64|     20|  return LowLevelHash(data, len, Seed(), kHashSalt);
   65|     20|}

_ZN4absl12lts_2023012513hash_internal15MixingHashState18combine_contiguousES2_PKhm:
  956|     40|                                            size_t size) {
  957|     40|    return MixingHashState(
  958|     40|        CombineContiguousImpl(hash_state.state_, first, size,
  959|     40|                              std::integral_constant<int, sizeof(size_t)>{}));
  960|     40|  }
_ZN4absl12lts_2023012513hash_internal15MixingHashStateC2Ev:
  984|     20|  MixingHashState() : state_(Seed()) {}
_ZN4absl12lts_2023012513hash_internal15MixingHashStateC2Em:
 1017|     40|  explicit MixingHashState(uint64_t state) : state_(state) {}
_ZN4absl12lts_2023012513hash_internal15MixingHashState8Read4To8EPKhm:
 1060|     20|  static uint64_t Read4To8(const unsigned char* p, size_t len) {
 1061|     20|    uint32_t low_mem = absl::base_internal::UnalignedLoad32(p);
 1062|     20|    uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4);
 1063|     20|#ifdef ABSL_IS_LITTLE_ENDIAN
 1064|     20|    uint32_t most_significant = high_mem;
 1065|     20|    uint32_t least_significant = low_mem;
 1066|       |#else
 1067|       |    uint32_t most_significant = low_mem;
 1068|       |    uint32_t least_significant = high_mem;
 1069|       |#endif
 1070|     20|    return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) |
 1071|     20|           least_significant;
 1072|     20|  }
_ZN4absl12lts_2023012513hash_internal15MixingHashState3MixEmm:
 1093|     40|  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
 1094|       |    // Though the 128-bit product on AArch64 needs two instructions, it is
 1095|       |    // still a good balance between speed and hash quality.
 1096|     40|    using MultType =
 1097|     40|        absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
 1098|       |    // We do the addition in 64-bit space to make sure the 128-bit
 1099|       |    // multiplication is fast. If we were to do it as MultType the compiler has
 1100|       |    // to assume that the high word is non-zero and needs to perform 2
 1101|       |    // multiplications instead of one.
 1102|     40|    MultType m = state + v;
 1103|     40|    m *= kMul;
 1104|     40|    return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2)));
 1105|     40|  }
_ZN4absl12lts_2023012513hash_internal15MixingHashState6Hash64EPKhm:
 1112|     20|                                                      size_t len) {
 1113|     20|#ifdef ABSL_HAVE_INTRINSIC_INT128
 1114|     20|    return LowLevelHashImpl(data, len);
 1115|       |#else
 1116|       |    return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len);
 1117|       |#endif
 1118|     20|  }
_ZN4absl12lts_2023012513hash_internal15MixingHashState4SeedEv:
 1136|     40|  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() {
 1137|     40|#if (!defined(__clang__) || __clang_major__ > 11) && \
 1138|     40|    !defined(__apple_build_version__)
 1139|     40|    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed));
 1140|       |#else
 1141|       |    // Workaround the absence of
 1142|       |    // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
 1143|       |    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(kSeed));
 1144|       |#endif
 1145|     40|  }
_ZN4absl12lts_2023012513hash_internal18PiecewiseChunkSizeEv:
   68|     20|constexpr size_t PiecewiseChunkSize() { return 1024; }
_ZN4absl12lts_2023012513hash_internal15MixingHashState21CombineContiguousImplEmPKhmNSt3__117integral_constantIiLi8EEE:
 1177|     40|    std::integral_constant<int, 8> /* sizeof_size_t */) {
 1178|       |  // For large values we use LowLevelHash or CityHash depending on the platform,
 1179|       |  // for small ones we just use a multiplicative hash.
 1180|     40|  uint64_t v;
 1181|     40|  if (len > 16) {
  ------------------
  |  Branch (1181:7): [True: 20, False: 20]
  ------------------
 1182|     20|    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
  ------------------
  |  |  177|     20|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (177:31): [True: 0, False: 20]
  |  |  |  Branch (177:49): [Folded - Ignored]
  |  |  |  Branch (177:58): [True: 0, False: 20]
  |  |  ------------------
  ------------------
 1183|      0|      return CombineLargeContiguousImpl64(state, first, len);
 1184|      0|    }
 1185|     20|    v = Hash64(first, len);
 1186|     20|  } else if (len > 8) {
  ------------------
  |  Branch (1186:14): [True: 0, False: 20]
  ------------------
 1187|       |    // This hash function was constructed by the ML-driven algorithm discovery
 1188|       |    // using reinforcement learning. We fed the agent lots of inputs from
 1189|       |    // microbenchmarks, SMHasher, low hamming distance from generated inputs and
 1190|       |    // picked up the one that was good on micro and macrobenchmarks.
 1191|      0|    auto p = Read9To16(first, len);
 1192|      0|    uint64_t lo = p.first;
 1193|      0|    uint64_t hi = p.second;
 1194|       |    // Rotation by 53 was found to be most often useful when discovering these
 1195|       |    // hashing algorithms with ML techniques.
 1196|      0|    lo = absl::rotr(lo, 53);
 1197|      0|    state += kMul;
 1198|      0|    lo += state;
 1199|      0|    state ^= hi;
 1200|      0|    uint128 m = state;
 1201|      0|    m *= lo;
 1202|      0|    return static_cast<uint64_t>(m ^ (m >> 64));
 1203|     20|  } else if (len >= 4) {
  ------------------
  |  Branch (1203:14): [True: 20, False: 0]
  ------------------
 1204|     20|    v = Read4To8(first, len);
 1205|     20|  } else if (len > 0) {
  ------------------
  |  Branch (1205:14): [True: 0, False: 0]
  ------------------
 1206|      0|    v = Read1To3(first, len);
 1207|      0|  } else {
 1208|       |    // Empty ranges have no effect.
 1209|      0|    return state;
 1210|      0|  }
 1211|     40|  return Mix(state, v);
 1212|     40|}
_ZN4absl12lts_2023012513hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINS0_11string_viewEJEEES3_S3_RKT_DpRKT0_:
 1240|     20|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1241|     20|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1242|     20|                        std::move(state), value),
 1243|     20|                    values...);
 1244|     20|}
_ZN4absl12lts_2023012513hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENS0_11string_viewEEENSt3__19enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueES9_E4typeES9_RKT0_:
  870|     20|        H> {
  871|     20|      return AbslHashValue(std::move(state), value);
  872|     20|    }
_ZN4absl12lts_2023012513hash_internal13AbslHashValueINS1_15MixingHashStateEEET_S4_NS0_11string_viewE:
  528|     20|H AbslHashValue(H hash_state, absl::string_view str) {
  529|     20|  return H::combine(
  530|     20|      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
  531|     20|      str.size());
  532|     20|}
_ZN4absl12lts_2023012513hash_internal13HashStateBaseINS1_15MixingHashStateEE18combine_contiguousIcEES3_S3_PKT_m:
 1249|     20|H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
 1250|     20|  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
 1251|     20|}
_ZN4absl12lts_2023012513hash_internal19hash_range_or_bytesINS1_15MixingHashStateEcEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES7_PKS6_m:
  818|     20|hash_range_or_bytes(H hash_state, const T* data, size_t size) {
  819|     20|  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
  820|     20|  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
  821|     20|}
_ZN4absl12lts_2023012513hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineImJEEES3_S3_RKT_DpRKT0_:
 1240|     20|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1241|     20|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1242|     20|                        std::move(state), value),
 1243|     20|                    values...);
 1244|     20|}
_ZN4absl12lts_2023012513hash_internal10HashSelect24UniquelyRepresentedProbe6InvokeINS1_15MixingHashStateEmEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES9_RKS8_:
  860|     20|        -> absl::enable_if_t<is_uniquely_represented<T>::value, H> {
  861|     20|      return hash_internal::hash_bytes(std::move(state), value);
  862|     20|    }
_ZN4absl12lts_2023012513hash_internal10hash_bytesINS1_15MixingHashStateEmEET_S4_RKT0_:
  326|     20|H hash_bytes(H hash_state, const T& value) {
  327|     20|  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
  328|     20|  return H::combine_contiguous(std::move(hash_state), start, sizeof(value));
  329|     20|}
_ZN4absl12lts_2023012513hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineES3_:
  220|     60|  static H combine(H state) { return state; }
_ZNK4absl12lts_2023012513hash_internal8HashImplINSt3__15tupleIJRKNS0_11string_viewEEEEEclERKS8_:
 1229|     20|  size_t operator()(const T& value) const {
 1230|     20|    return MixingHashState::hash(value);
 1231|     20|  }
_ZN4absl12lts_2023012513hash_internal15MixingHashState4hashINSt3__15tupleIJRKNS0_11string_viewEEEELi0EEEmRKT_:
  977|     20|  static size_t hash(const T& value) {
  978|     20|    return static_cast<size_t>(combine(MixingHashState{}, value).state_);
  979|     20|  }
_ZN4absl12lts_2023012513hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__15tupleIJRKNS0_11string_viewEEEEJEEES3_S3_RKT_DpRKT0_:
 1240|     20|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1241|     20|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1242|     20|                        std::move(state), value),
 1243|     20|                    values...);
 1244|     20|}
_ZN4absl12lts_2023012513hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__15tupleIJRKNS0_11string_viewEEEEEENS6_9enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESD_E4typeESD_RKT0_:
  870|     20|        H> {
  871|     20|      return AbslHashValue(std::move(state), value);
  872|     20|    }
_ZN4absl12lts_2023012513hash_internal13AbslHashValueINS1_15MixingHashStateEJRKNS0_11string_viewEEEENSt3__19enable_ifIXsr4absl11conjunctionIDpNS1_11is_hashableIT0_EEEE5valueET_E4typeESD_RKNS7_5tupleIJDpSA_EEE:
  488|     20|AbslHashValue(H hash_state, const std::tuple<Ts...>& t) {
  489|     20|  return hash_internal::hash_tuple(std::move(hash_state), t,
  490|     20|                                   absl::make_index_sequence<sizeof...(Ts)>());
  491|     20|}
_ZN4absl12lts_2023012513hash_internal10hash_tupleINS1_15MixingHashStateENSt3__15tupleIJRKNS0_11string_viewEEEEJLm0EEEET_SA_RKT0_NS0_16integer_sequenceImJXspT1_EEEE:
  475|     20|H hash_tuple(H hash_state, const Tuple& t, absl::index_sequence<Is...>) {
  476|     20|  return H::combine(std::move(hash_state), std::get<Is>(t)...);
  477|     20|}

_ZN4absl12lts_2023012513hash_internal12LowLevelHashEPKvmmPKm:
   31|     20|                      const uint64_t salt[5]) {
   32|     20|  const uint8_t* ptr = static_cast<const uint8_t*>(data);
   33|     20|  uint64_t starting_length = static_cast<uint64_t>(len);
   34|     20|  uint64_t current_state = seed ^ salt[0];
   35|       |
   36|     20|  if (len > 64) {
  ------------------
  |  Branch (36:7): [True: 0, False: 20]
  ------------------
   37|       |    // If we have more than 64 bytes, we're going to handle chunks of 64
   38|       |    // bytes at a time. We're going to build up two separate hash states
   39|       |    // which we will then hash together.
   40|      0|    uint64_t duplicated_state = current_state;
   41|       |
   42|      0|    do {
   43|      0|      uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
   44|      0|      uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
   45|      0|      uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
   46|      0|      uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
   47|      0|      uint64_t e = absl::base_internal::UnalignedLoad64(ptr + 32);
   48|      0|      uint64_t f = absl::base_internal::UnalignedLoad64(ptr + 40);
   49|      0|      uint64_t g = absl::base_internal::UnalignedLoad64(ptr + 48);
   50|      0|      uint64_t h = absl::base_internal::UnalignedLoad64(ptr + 56);
   51|       |
   52|      0|      uint64_t cs0 = Mix(a ^ salt[1], b ^ current_state);
   53|      0|      uint64_t cs1 = Mix(c ^ salt[2], d ^ current_state);
   54|      0|      current_state = (cs0 ^ cs1);
   55|       |
   56|      0|      uint64_t ds0 = Mix(e ^ salt[3], f ^ duplicated_state);
   57|      0|      uint64_t ds1 = Mix(g ^ salt[4], h ^ duplicated_state);
   58|      0|      duplicated_state = (ds0 ^ ds1);
   59|       |
   60|      0|      ptr += 64;
   61|      0|      len -= 64;
   62|      0|    } while (len > 64);
  ------------------
  |  Branch (62:14): [True: 0, False: 0]
  ------------------
   63|       |
   64|      0|    current_state = current_state ^ duplicated_state;
   65|      0|  }
   66|       |
   67|       |  // We now have a data `ptr` with at most 64 bytes and the current state
   68|       |  // of the hashing state machine stored in current_state.
   69|     44|  while (len > 16) {
  ------------------
  |  Branch (69:10): [True: 24, False: 20]
  ------------------
   70|     24|    uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
   71|     24|    uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
   72|       |
   73|     24|    current_state = Mix(a ^ salt[1], b ^ current_state);
   74|       |
   75|     24|    ptr += 16;
   76|     24|    len -= 16;
   77|     24|  }
   78|       |
   79|       |  // We now have a data `ptr` with at most 16 bytes.
   80|     20|  uint64_t a = 0;
   81|     20|  uint64_t b = 0;
   82|     20|  if (len > 8) {
  ------------------
  |  Branch (82:7): [True: 16, False: 4]
  ------------------
   83|       |    // When we have at least 9 and at most 16 bytes, set A to the first 64
   84|       |    // bits of the input and B to the last 64 bits of the input. Yes, they will
   85|       |    // overlap in the middle if we are working with less than the full 16
   86|       |    // bytes.
   87|     16|    a = absl::base_internal::UnalignedLoad64(ptr);
   88|     16|    b = absl::base_internal::UnalignedLoad64(ptr + len - 8);
   89|     16|  } else if (len > 3) {
  ------------------
  |  Branch (89:14): [True: 4, False: 0]
  ------------------
   90|       |    // If we have at least 4 and at most 8 bytes, set A to the first 32
   91|       |    // bits and B to the last 32 bits.
   92|      4|    a = absl::base_internal::UnalignedLoad32(ptr);
   93|      4|    b = absl::base_internal::UnalignedLoad32(ptr + len - 4);
   94|      4|  } else if (len > 0) {
  ------------------
  |  Branch (94:14): [True: 0, False: 0]
  ------------------
   95|       |    // If we have at least 1 and at most 3 bytes, read all of the provided
   96|       |    // bits into A, with some adjustments.
   97|      0|    a = static_cast<uint64_t>((ptr[0] << 16) | (ptr[len >> 1] << 8) |
   98|      0|                              ptr[len - 1]);
   99|      0|    b = 0;
  100|      0|  } else {
  101|      0|    a = 0;
  102|      0|    b = 0;
  103|      0|  }
  104|       |
  105|     20|  uint64_t w = Mix(a ^ salt[1], b ^ current_state);
  106|     20|  uint64_t z = salt[1] ^ starting_length;
  107|     20|  return Mix(w, z);
  108|     20|}
low_level_hash.cc:_ZN4absl12lts_2023012513hash_internalL3MixEmm:
   24|     64|static uint64_t Mix(uint64_t v0, uint64_t v1) {
   25|     64|  absl::uint128 p = v0;
   26|     64|  p *= v1;
   27|     64|  return absl::Uint128Low64(p) ^ absl::Uint128High64(p);
   28|     64|}

_ZN4absl12lts_2023012512log_internal21GetReferenceableValueEl:
  375|    780|inline constexpr long GetReferenceableValue(long t) { return t; }  // NOLINT
_ZN4absl12lts_2023012512log_internal12Check_LEImplIllEEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKT_RKT0_PKc:
  324|    390|                                             const char* exprtext) {     \
  325|    390|    using U1 = CheckOpStreamType<T1>;                                    \
  326|    390|    using U2 = CheckOpStreamType<T2>;                                    \
  327|    390|    return ABSL_PREDICT_TRUE(v1 op v2)                                   \
  ------------------
  |  |  178|    390|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (178:30): [True: 390, False: 0]
  |  |  |  Branch (178:48): [Folded - Ignored]
  |  |  |  Branch (178:57): [True: 390, False: 0]
  |  |  ------------------
  ------------------
  328|    390|               ? nullptr                                                 \
  329|    390|               : MakeCheckOpString<U1, U2>(v1, v2, exprtext);            \
  330|    390|  }                                                                      \

_ZN4absl12lts_2023012511countr_zeroIjEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
   92|     26|    countr_zero(T x) noexcept {
   93|     26|  return numeric_internal::CountTrailingZeroes(x);
   94|     26|}

_ZN4absl12lts_202301257uint128mLES1_:
  617|     64|inline uint128& uint128::operator*=(uint128 other) {
  618|     64|  *this = *this * other;
  619|     64|  return *this;
  620|     64|}
_ZN4absl12lts_2023012512Uint128Low64ENS0_7uint128E:
  632|     64|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl12lts_2023012513Uint128High64ENS0_7uint128E:
  634|     64|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZNK4absl12lts_202301257uint128cvoEv:
  767|    128|constexpr uint128::operator unsigned __int128() const {
  768|    128|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  769|    128|}
_ZN4absl12lts_20230125mlENS0_7uint128ES1_:
  977|     64|inline uint128 operator*(uint128 lhs, uint128 rhs) {
  978|     64|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  979|       |  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
  980|       |  // can be used for uint128 storage.
  981|     64|  return static_cast<unsigned __int128>(lhs) *
  982|     64|         static_cast<unsigned __int128>(rhs);
  983|       |#elif defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
  984|       |  uint64_t carry;
  985|       |  uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
  986|       |  return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
  987|       |                         Uint128High64(lhs) * Uint128Low64(rhs) + carry,
  988|       |                     low);
  989|       |#else   // ABSL_HAVE_INTRINSIC128
  990|       |  uint64_t a32 = Uint128Low64(lhs) >> 32;
  991|       |  uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
  992|       |  uint64_t b32 = Uint128Low64(rhs) >> 32;
  993|       |  uint64_t b00 = Uint128Low64(rhs) & 0xffffffff;
  994|       |  uint128 result =
  995|       |      MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) +
  996|       |                      Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32,
  997|       |                  a00 * b00);
  998|       |  result += uint128(a32 * b00) << 32;
  999|       |  result += uint128(a00 * b32) << 32;
 1000|       |  return result;
 1001|       |#endif  // ABSL_HAVE_INTRINSIC128
 1002|     64|}
_ZN4absl12lts_202301257uint128C2Em:
  655|    128|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
_ZN4absl12lts_202301257uint128C2Eo:
  665|     64|      hi_{static_cast<uint64_t>(v >> 64)} {}

_ZN4absl12lts_2023012516numeric_internal28CountTrailingZeroesNonzero32Ej:
  251|     26|CountTrailingZeroesNonzero32(uint32_t x) {
  252|     26|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz)
  253|     26|  static_assert(sizeof(unsigned int) == sizeof(x),
  254|     26|                "__builtin_ctz does not take 32-bit arg");
  255|     26|  return __builtin_ctz(x);
  256|       |#elif defined(_MSC_VER) && !defined(__clang__)
  257|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  258|       |  _BitScanForward(&result, x);
  259|       |  return result;
  260|       |#else
  261|       |  int c = 31;
  262|       |  x &= ~x + 1;
  263|       |  if (x & 0x0000FFFF) c -= 16;
  264|       |  if (x & 0x00FF00FF) c -= 8;
  265|       |  if (x & 0x0F0F0F0F) c -= 4;
  266|       |  if (x & 0x33333333) c -= 2;
  267|       |  if (x & 0x55555555) c -= 1;
  268|       |  return c;
  269|       |#endif
  270|     26|}
_ZN4absl12lts_2023012516numeric_internal19CountTrailingZeroesIjEEiT_:
  317|     26|CountTrailingZeroes(T x) noexcept {
  318|     26|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  319|     26|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  320|     26|                "T must have a power-of-2 size");
  321|     26|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  322|     26|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (322:10): [True: 0, False: 26]
  ------------------
  323|     26|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (323:20): [Folded - Ignored]
  ------------------
  324|     26|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  325|     26|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (325:27): [Folded - Ignored]
  ------------------
  326|     26|                              ? CountTrailingZeroesNonzero32(
  327|     26|                                    static_cast<uint32_t>(x))
  328|     26|                              : CountTrailingZeroesNonzero64(x)));
  329|     26|}

_ZN4absl12lts_2023012515status_internal9StatusRepC2ENS0_10StatusCodeENS0_11string_viewENSt3__110unique_ptrINS0_13InlinedVectorINS1_7PayloadELm1ENS5_9allocatorIS8_EEEENS5_14default_deleteISB_EEEE:
   65|    114|        payloads(std::move(payloads_arg)) {}

_ZN4absl12lts_202301256Status15UnrefNonInlinedEm:
  214|    114|void Status::UnrefNonInlined(uintptr_t rep) {
  215|    114|  status_internal::StatusRep* r = RepToPointer(rep);
  216|       |  // Fast path: if ref==1, there is no need for a RefCountDec (since
  217|       |  // this is the only reference and therefore no other thread is
  218|       |  // allowed to be mucking with r).
  219|    114|  if (r->ref.load(std::memory_order_acquire) == 1 ||
  ------------------
  |  Branch (219:7): [True: 114, False: 0]
  ------------------
  220|    114|      r->ref.fetch_sub(1, std::memory_order_acq_rel) - 1 == 0) {
  ------------------
  |  Branch (220:7): [True: 0, False: 0]
  ------------------
  221|    114|    delete r;
  222|    114|  }
  223|    114|}
_ZN4absl12lts_202301256StatusC2ENS0_10StatusCodeENS0_11string_viewE:
  226|    114|    : rep_(CodeToInlinedRep(code)) {
  227|    114|  if (code != absl::StatusCode::kOk && !msg.empty()) {
  ------------------
  |  Branch (227:7): [True: 114, False: 0]
  |  Branch (227:40): [True: 114, False: 0]
  ------------------
  228|    114|    rep_ = PointerToRep(new status_internal::StatusRep(code, msg, nullptr));
  229|    114|  }
  230|    114|}

_ZNK4absl12lts_202301256Status2okEv:
  802|  1.33M|inline bool Status::ok() const {
  803|  1.33M|  return rep_ == CodeToInlinedRep(absl::StatusCode::kOk);
  804|  1.33M|}
_ZN4absl12lts_202301256Status16CodeToInlinedRepENS0_10StatusCodeE:
  852|  1.33M|inline uintptr_t Status::CodeToInlinedRep(absl::StatusCode code) {
  853|  1.33M|  return static_cast<uintptr_t>(code) << 2;
  854|  1.33M|}
_ZN4absl12lts_202301256Status9IsInlinedEm:
  842|    840|inline bool Status::IsInlined(uintptr_t rep) { return (rep & 1) == 0; }
_ZN4absl12lts_202301256Status12RepToPointerEm:
  861|    114|inline status_internal::StatusRep* Status::RepToPointer(uintptr_t rep) {
  862|    114|  assert(!IsInlined(rep));
  863|    114|  return reinterpret_cast<status_internal::StatusRep*>(rep - 1);
  864|    114|}
_ZN4absl12lts_202301256StatusD2Ev:
  800|    726|inline Status::~Status() { Unref(rep_); }
_ZN4absl12lts_202301256Status5UnrefEm:
  876|    840|inline void Status::Unref(uintptr_t rep) {
  877|    840|  if (!IsInlined(rep)) {
  ------------------
  |  Branch (877:7): [True: 114, False: 726]
  ------------------
  878|    114|    UnrefNonInlined(rep);
  879|    114|  }
  880|    840|}
_ZN4absl12lts_202301256StatusaSEOS1_:
  778|    114|inline Status& Status::operator=(Status&& x) {
  779|    114|  uintptr_t old_rep = rep_;
  780|    114|  if (x.rep_ != old_rep) {
  ------------------
  |  Branch (780:7): [True: 114, False: 0]
  ------------------
  781|    114|    rep_ = x.rep_;
  782|    114|    x.rep_ = MovedFromRep();
  783|    114|    Unref(old_rep);
  784|    114|  }
  785|    114|  return *this;
  786|    114|}
_ZN4absl12lts_202301256Status12MovedFromRepEv:
  848|    114|inline uintptr_t Status::MovedFromRep() {
  849|    114|  return CodeToInlinedRep(absl::StatusCode::kInternal) | 2;
  850|    114|}
_ZN4absl12lts_202301256Status12PointerToRepEPNS0_15status_internal9StatusRepE:
  866|    114|inline uintptr_t Status::PointerToRep(status_internal::StatusRep* rep) {
  867|    114|  return reinterpret_cast<uintptr_t>(rep) + 1;
  868|    114|}
_ZN4absl12lts_202301256StatusC2Ev:
  758|    612|inline Status::Status() : rep_(CodeToInlinedRep(absl::StatusCode::kOk)) {}

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

_ZN4absl12lts_2023012510StartsWithENS0_11string_viewES1_:
   59|    162|                       absl::string_view prefix) noexcept {
   60|    162|  return prefix.empty() ||
  ------------------
  |  Branch (60:10): [True: 0, False: 162]
  ------------------
   61|    162|         (text.size() >= prefix.size() &&
  ------------------
  |  Branch (61:11): [True: 82, False: 80]
  ------------------
   62|    162|          memcmp(text.data(), prefix.data(), prefix.size()) == 0);
  ------------------
  |  Branch (62:11): [True: 8, False: 74]
  ------------------
   63|    162|}

_ZN4absl12lts_202301256StrCatERKNS0_8AlphaNumES3_S3_:
  113|    246|std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c) {
  114|    246|  std::string result;
  115|    246|  strings_internal::STLStringResizeUninitialized(
  116|    246|      &result, a.size() + b.size() + c.size());
  117|    246|  char* const begin = &result[0];
  118|    246|  char* out = begin;
  119|    246|  out = Append(out, a);
  120|    246|  out = Append(out, b);
  121|    246|  out = Append(out, c);
  122|    246|  assert(out == begin + result.size());
  123|    246|  return result;
  124|    246|}
str_cat.cc:_ZN4absl12lts_20230125L6AppendEPcRKNS0_8AlphaNumE:
   91|    738|static char* Append(char* out, const AlphaNum& x) {
   92|       |  // memcpy is allowed to overwrite arbitrary memory, so doing this after the
   93|       |  // call would force an extra fetch of x.size().
   94|    738|  char* after = out + x.size();
   95|    738|  if (x.size() != 0) {
  ------------------
  |  Branch (95:7): [True: 738, False: 0]
  ------------------
   96|    738|    memcpy(out, x.data(), x.size());
   97|    738|  }
   98|    738|  return after;
   99|    738|}

_ZN4absl12lts_202301258AlphaNumC2EPKc:
  294|    246|      : piece_(NullSafeStringView(c_str)) {}      // NOLINT(runtime/explicit)
_ZN4absl12lts_202301258AlphaNumC2ENS0_11string_viewE:
  295|    492|  AlphaNum(absl::string_view pc) : piece_(pc) {}  // NOLINT(runtime/explicit)
_ZNK4absl12lts_202301258AlphaNum4sizeEv:
  315|  2.95k|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl12lts_202301258AlphaNum4dataEv:
  316|    738|  const char* data() const { return piece_.data(); }

_ZN4absl12lts_2023012511string_viewC2EPKc:
  198|    266|      : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}
_ZN4absl12lts_2023012511string_view14StrlenInternalEPKc:
  607|    266|  static constexpr size_type StrlenInternal(const char* str) {
  608|       |#if defined(_MSC_VER) && _MSC_VER >= 1910 && !defined(__clang__)
  609|       |    // MSVC 2017+ can evaluate this at compile-time.
  610|       |    const char* begin = str;
  611|       |    while (*str != '\0') ++str;
  612|       |    return str - begin;
  613|       |#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \
  614|       |    (defined(__GNUC__) && !defined(__clang__))
  615|       |    // GCC has __builtin_strlen according to
  616|       |    // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
  617|       |    // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
  618|       |    // __builtin_strlen is constexpr.
  619|    266|    return __builtin_strlen(str);
  620|       |#else
  621|       |    return str ? strlen(str) : 0;
  622|       |#endif
  623|    266|  }
_ZN4absl12lts_2023012511string_viewC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE:
  191|  3.30k|      : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {}
_ZN4absl12lts_2023012511string_viewC2EPKcmNS1_18SkipCheckLengthTagE:
  598|  3.30k|      : ptr_(data), length_(len) {}
_ZN4absl12lts_2023012511string_viewC2EPKcm:
  202|  1.06k|      : ptr_(data), length_(CheckLengthInternal(len)) {}
_ZNK4absl12lts_2023012511string_view5beginEv:
  214|     96|  constexpr const_iterator begin() const noexcept { return ptr_; }
_ZNK4absl12lts_2023012511string_view3endEv:
  221|     96|  constexpr const_iterator end() const noexcept { return ptr_ + length_; }
_ZNK4absl12lts_2023012511string_view4sizeEv:
  271|  6.09k|  constexpr size_type size() const noexcept { return length_; }
_ZNK4absl12lts_2023012511string_view5emptyEv:
  286|  1.58k|  constexpr bool empty() const noexcept { return length_ == 0; }
_ZNK4absl12lts_2023012511string_viewixEm:
  292|      8|  constexpr const_reference operator[](size_type i) const {
  293|      8|    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
  ------------------
  |  |  128|      8|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|      8|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  294|      8|  }
_ZNK4absl12lts_2023012511string_view4dataEv:
  330|  1.41k|  constexpr const_pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_2023012511string_view6substrEmm:
  393|  1.05k|  constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
  394|  1.05k|    return ABSL_PREDICT_FALSE(pos > length_)
  ------------------
  |  |  177|  1.05k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (177:31): [True: 0, False: 1.05k]
  |  |  |  Branch (177:49): [Folded - Ignored]
  |  |  |  Branch (177:58): [True: 0, False: 1.05k]
  |  |  ------------------
  ------------------
  395|  1.05k|               ? (base_internal::ThrowStdOutOfRange(
  396|      0|                      "absl::string_view::substr"),
  397|      0|                  string_view())
  398|  1.05k|               : string_view(ptr_ + pos, Min(n, length_ - pos));
  399|  1.05k|  }
_ZNK4absl12lts_2023012511string_view7compareES1_:
  407|  1.07k|  constexpr int compare(string_view x) const noexcept {
  408|  1.07k|    return CompareImpl(length_, x.length_,
  409|  1.07k|                       Min(length_, x.length_) == 0
  ------------------
  |  Branch (409:24): [True: 0, False: 1.07k]
  ------------------
  410|  1.07k|                           ? 0
  411|  1.07k|                           : ABSL_INTERNAL_STRING_VIEW_MEMCMP(
  ------------------
  |  |   61|  1.07k|#define ABSL_INTERNAL_STRING_VIEW_MEMCMP __builtin_memcmp
  ------------------
  412|  1.07k|                                 ptr_, x.ptr_, Min(length_, x.length_)));
  413|  1.07k|  }
_ZN4absl12lts_2023012511string_view19CheckLengthInternalEm:
  603|  1.06k|  static constexpr size_type CheckLengthInternal(size_type len) {
  604|  1.06k|    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
  ------------------
  |  |  128|  1.06k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|  1.06k|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  605|  1.06k|  }
_ZN4absl12lts_2023012511string_view3MinEmm:
  625|  3.20k|  static constexpr size_t Min(size_type length_a, size_type length_b) {
  626|  3.20k|    return length_a < length_b ? length_a : length_b;
  ------------------
  |  Branch (626:12): [True: 356, False: 2.85k]
  ------------------
  627|  3.20k|  }
_ZN4absl12lts_2023012511string_view11CompareImplEmmi:
  630|  1.07k|                                   int compare_result) {
  631|  1.07k|    return compare_result == 0 ? static_cast<int>(length_a > length_b) -
  ------------------
  |  Branch (631:12): [True: 546, False: 532]
  ------------------
  632|    546|                                     static_cast<int>(length_a < length_b)
  633|  1.07k|                               : (compare_result < 0 ? -1 : 1);
  ------------------
  |  Branch (633:35): [True: 364, False: 168]
  ------------------
  634|  1.07k|  }
_ZN4absl12lts_20230125eqENS0_11string_viewES1_:
  643|    162|constexpr bool operator==(string_view x, string_view y) noexcept {
  644|    162|  return x.size() == y.size() &&
  ------------------
  |  Branch (644:10): [True: 14, False: 148]
  ------------------
  645|    162|         (x.empty() ||
  ------------------
  |  Branch (645:11): [True: 0, False: 14]
  ------------------
  646|     14|          ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0);
  ------------------
  |  |   61|     14|#define ABSL_INTERNAL_STRING_VIEW_MEMCMP __builtin_memcmp
  ------------------
  |  Branch (646:11): [True: 0, False: 14]
  ------------------
  647|    162|}
_ZN4absl12lts_20230125ltENS0_11string_viewES1_:
  653|    552|constexpr bool operator<(string_view x, string_view y) noexcept {
  654|    552|  return x.compare(y) < 0;
  655|    552|}
_ZN4absl12lts_2023012518NullSafeStringViewEPKc:
  697|    246|constexpr string_view NullSafeStringView(const char* p) {
  698|    246|  return p ? string_view(p) : string_view();
  ------------------
  |  Branch (698:10): [True: 246, False: 0]
  ------------------
  699|    246|}
_ZNK4absl12lts_2023012511string_viewcvNSt3__112basic_stringIcNS2_11char_traitsIcEET_EEINS2_9allocatorIcEEEEv:
  366|    222|  explicit operator std::basic_string<char, traits_type, A>() const {
  367|    222|    if (!data()) return {};
  ------------------
  |  Branch (367:9): [True: 0, False: 222]
  ------------------
  368|    222|    return std::basic_string<char, traits_type, A>(data(), size());
  369|    222|  }

_ZN4absl12lts_2023012524synchronization_internal14InvalidGraphIdEv:
   58|      6|inline GraphId InvalidGraphId() {
   59|      6|  return GraphId{0};
   60|      6|}

_ZN4absl12lts_202301255Mutex4LockEv:
 1507|      6|void Mutex::Lock() {
 1508|      6|  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
 1509|      6|  GraphId id = DebugOnlyDeadlockCheck(this);
 1510|      6|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1511|       |  // try fast acquire, then spin loop
 1512|      6|  if ((v & (kMuWriter | kMuReader | kMuEvent)) != 0 ||
  ------------------
  |  Branch (1512:7): [True: 0, False: 6]
  ------------------
 1513|      6|      !mu_.compare_exchange_strong(v, kMuWriter | v,
  ------------------
  |  Branch (1513:7): [True: 0, False: 6]
  ------------------
 1514|      6|                                   std::memory_order_acquire,
 1515|      6|                                   std::memory_order_relaxed)) {
 1516|       |    // try spin acquire, then slow loop
 1517|      0|    if (!TryAcquireWithSpinning(&this->mu_)) {
  ------------------
  |  Branch (1517:9): [True: 0, False: 0]
  ------------------
 1518|      0|      this->LockSlow(kExclusive, nullptr, 0);
 1519|      0|    }
 1520|      0|  }
 1521|      6|  DebugOnlyLockEnter(this, id);
 1522|      6|  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 1523|      6|}
_ZN4absl12lts_202301255Mutex6UnlockEv:
 1713|      6|void Mutex::Unlock() {
 1714|      6|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
 1715|      6|  DebugOnlyLockLeave(this);
 1716|      6|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1717|       |
 1718|      6|  if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) {
  ------------------
  |  Branch (1718:7): [Folded - Ignored]
  |  Branch (1718:21): [True: 0, False: 0]
  ------------------
 1719|      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,         \
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (51:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1720|      0|                 static_cast<unsigned>(v));
 1721|      0|  }
 1722|       |
 1723|       |  // should_try_cas is whether we'll try a compare-and-swap immediately.
 1724|       |  // NOTE: optimized out when kDebugMode is false.
 1725|      6|  bool should_try_cas = ((v & (kMuEvent | kMuWriter)) == kMuWriter &&
  ------------------
  |  Branch (1725:26): [True: 6, False: 0]
  ------------------
 1726|      6|                          (v & (kMuWait | kMuDesig)) != kMuWait);
  ------------------
  |  Branch (1726:27): [True: 6, False: 0]
  ------------------
 1727|       |  // But, we can use an alternate computation of it, that compilers
 1728|       |  // currently don't find on their own.  When that changes, this function
 1729|       |  // can be simplified.
 1730|      6|  intptr_t x = (v ^ (kMuWriter | kMuWait)) & (kMuWriter | kMuEvent);
 1731|      6|  intptr_t y = (v ^ (kMuWriter | kMuWait)) & (kMuWait | kMuDesig);
 1732|       |  // Claim: "x == 0 && y > 0" is equal to should_try_cas.
 1733|       |  // Also, because kMuWriter and kMuEvent exceed kMuDesig and kMuWait,
 1734|       |  // all possible non-zero values for x exceed all possible values for y.
 1735|       |  // Therefore, (x == 0 && y > 0) == (x < y).
 1736|      6|  if (kDebugMode && should_try_cas != (x < y)) {
  ------------------
  |  Branch (1736:7): [Folded - Ignored]
  |  Branch (1736:21): [True: 0, False: 0]
  ------------------
 1737|       |    // We would usually use PRIdPTR here, but is not correctly implemented
 1738|       |    // within the android toolchain.
 1739|      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,         \
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (51:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1740|      0|                 static_cast<long long>(v), static_cast<long long>(x),
 1741|      0|                 static_cast<long long>(y));
 1742|      0|  }
 1743|      6|  if (x < y &&
  ------------------
  |  Branch (1743:7): [True: 6, False: 0]
  ------------------
 1744|      6|      mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
  ------------------
  |  Branch (1744:7): [True: 6, False: 0]
  ------------------
 1745|      6|                                  std::memory_order_release,
 1746|      6|                                  std::memory_order_relaxed)) {
 1747|       |    // fast writer release (writer with no waiters or with designated waker)
 1748|      6|  } else {
 1749|      0|    this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
 1750|      0|  }
 1751|      6|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
 1752|      6|}
mutex.cc:_ZN4absl12lts_20230125L22DebugOnlyDeadlockCheckEPNS0_5MutexE:
 1449|      6|static inline GraphId DebugOnlyDeadlockCheck(Mutex *mu) {
 1450|      6|  if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1450:7): [Folded - Ignored]
  |  Branch (1450:21): [True: 0, False: 0]
  ------------------
 1451|      0|                        OnDeadlockCycle::kIgnore) {
 1452|      0|    return DeadlockCheck(mu);
 1453|      6|  } else {
 1454|      6|    return InvalidGraphId();
 1455|      6|  }
 1456|      6|}
mutex.cc:_ZN4absl12lts_20230125L18DebugOnlyLockEnterEPNS0_5MutexENS0_24synchronization_internal7GraphIdE:
 1286|      6|static inline void DebugOnlyLockEnter(Mutex *mu, GraphId id) {
 1287|      6|  if (kDebugMode) {
  ------------------
  |  Branch (1287:7): [Folded - Ignored]
  ------------------
 1288|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1288:9): [True: 0, False: 0]
  ------------------
 1289|      0|        OnDeadlockCycle::kIgnore) {
 1290|      0|      LockEnter(mu, id, Synch_GetAllLocks());
 1291|      0|    }
 1292|      0|  }
 1293|      6|}
mutex.cc:_ZN4absl12lts_20230125L18DebugOnlyLockLeaveEPNS0_5MutexE:
 1296|      6|static inline void DebugOnlyLockLeave(Mutex *mu) {
 1297|      6|  if (kDebugMode) {
  ------------------
  |  Branch (1297:7): [Folded - Ignored]
  ------------------
 1298|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1298:9): [True: 0, False: 0]
  ------------------
 1299|      0|        OnDeadlockCycle::kIgnore) {
 1300|      0|      LockLeave(mu, GetGraphId(mu), Synch_GetAllLocks());
 1301|      0|    }
 1302|      0|  }
 1303|      6|}

_ZN4absl12lts_202301259MutexLockC2EPNS0_5MutexE:
  534|      6|  explicit MutexLock(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
  535|      6|    this->mu_->Lock();
  536|      6|  }
_ZN4absl12lts_202301259MutexLockD2Ev:
  552|      6|  ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->Unlock(); }
_ZN4absl12lts_202301255MutexC2Ev:
  975|      4|inline Mutex::Mutex() : mu_(0) {
  976|      4|  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
  977|      4|}

_ZN4absl12lts_2023012516compare_internal27compare_result_as_less_thanIbLi0EEEbT_:
  548|    522|constexpr bool compare_result_as_less_than(const BoolT r) { return r; }

_ZN4absl12lts_202301257forwardIjEEOT_RNSt3__116remove_referenceIS2_E4typeE:
  231|     12|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|     12|  return static_cast<T&&>(t);
  233|     12|}
_ZN4absl12lts_202301257forwardINS0_18container_internal20HashtablezInfoHandleEEEOT_RNSt3__116remove_referenceIS4_E4typeE:
  231|     24|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|     24|  return static_cast<T&&>(t);
  233|     24|}
_ZN4absl12lts_202301257forwardIRmEEOT_RNSt3__116remove_referenceIS3_E4typeE:
  231|     12|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|     12|  return static_cast<T&&>(t);
  233|     12|}
_ZN4absl12lts_202301257forwardINS0_18container_internal12CommonFieldsEEEOT_RNSt3__116remove_referenceIS4_E4typeE:
  231|     12|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|     12|  return static_cast<T&&>(t);
  233|     12|}
_ZN4absl12lts_202301257forwardINS0_18container_internal6HashEqIPKN6google8protobuf10DescriptorEvE4HashEEEOT_RNSt3__116remove_referenceISB_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardINS0_18container_internal6HashEqIPKN6google8protobuf10DescriptorEvE2EqEEEOT_RNSt3__116remove_referenceISB_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
message.cc:_ZN4absl12lts_202301257forwardIN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashEEEOT_RNSt3__116remove_referenceIS7_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
message.cc:_ZN4absl12lts_202301257forwardIN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory18DescriptorByNameEqEEEOT_RNSt3__116remove_referenceIS7_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardINSt3__19allocatorIPKN6google8protobuf8internal15DescriptorTableEEEEEOT_RNS2_16remove_referenceISB_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardINSt3__19allocatorINS2_4pairIKPKN6google8protobuf10DescriptorEPKNS6_7MessageEEEEEEEOT_RNS2_16remove_referenceISG_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardIRKNS0_18container_internal19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareENS7_9FileEntryEE15checked_compareEEEOT_RNSt3__116remove_referenceISE_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardIRKNSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryEEEEEOT_RNS2_16remove_referenceISC_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardIPNS0_18container_internal10btree_nodeINS2_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntryENS8_11FileCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEEEOT_RNSB_16remove_referenceISH_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardIRKNS0_18container_internal19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareENS7_11SymbolEntryEE15checked_compareEEEOT_RNSt3__116remove_referenceISE_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardIRKNSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEEEEOT_RNS2_16remove_referenceISC_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardIPNS0_18container_internal10btree_nodeINS2_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS8_13SymbolCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEEEOT_RNSB_16remove_referenceISH_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardIRKNS0_18container_internal19key_compare_adapterIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex16ExtensionCompareENS7_14ExtensionEntryEE15checked_compareEEEOT_RNSt3__116remove_referenceISE_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardIRKNSt3__19allocatorIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex14ExtensionEntryEEEEEOT_RNS2_16remove_referenceISC_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}
_ZN4absl12lts_202301257forwardIPNS0_18container_internal10btree_nodeINS2_10set_paramsIN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex14ExtensionEntryENS8_16ExtensionCompareENSt3__19allocatorIS9_EELi256ELb0EEEEEEEOT_RNSB_16remove_referenceISH_E4typeE:
  231|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  232|      6|  return static_cast<T&&>(t);
  233|      6|}

_ZN7testing8internal16BoolFromGTestEnvEPKcb:
 1331|     18|bool BoolFromGTestEnv(const char* flag, bool default_value) {
 1332|       |#if defined(GTEST_GET_BOOL_FROM_ENV_)
 1333|       |  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
 1334|       |#else
 1335|     18|  const std::string env_var = FlagToEnvVar(flag);
 1336|     18|  const char* const string_value = posix::GetEnv(env_var.c_str());
 1337|     18|  return string_value == nullptr ? default_value
  ------------------
  |  Branch (1337:10): [True: 18, False: 0]
  ------------------
 1338|     18|                                 : strcmp(string_value, "0") != 0;
 1339|     18|#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
 1340|     18|}
_ZN7testing8internal17Int32FromGTestEnvEPKci:
 1345|      6|Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
 1346|       |#if defined(GTEST_GET_INT32_FROM_ENV_)
 1347|       |  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
 1348|       |#else
 1349|      6|  const std::string env_var = FlagToEnvVar(flag);
 1350|      6|  const char* const string_value = posix::GetEnv(env_var.c_str());
 1351|      6|  if (string_value == nullptr) {
  ------------------
  |  Branch (1351:7): [True: 6, False: 0]
  ------------------
 1352|       |    // The environment variable is not set.
 1353|      6|    return default_value;
 1354|      6|  }
 1355|       |
 1356|      0|  Int32 result = default_value;
 1357|      0|  if (!ParseInt32(Message() << "Environment variable " << env_var,
  ------------------
  |  Branch (1357:7): [True: 0, False: 0]
  ------------------
 1358|      0|                  string_value, &result)) {
 1359|      0|    printf("The default value %s is used.\n",
 1360|      0|           (Message() << default_value).GetString().c_str());
 1361|      0|    fflush(stdout);
 1362|      0|    return default_value;
 1363|      0|  }
 1364|       |
 1365|      0|  return result;
 1366|      0|#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
 1367|      0|}
_ZN7testing8internal25OutputFlagAlsoCheckEnvVarEv:
 1377|      2|std::string OutputFlagAlsoCheckEnvVar(){
 1378|      2|  std::string default_value_for_output_flag = "";
 1379|      2|  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
 1380|      2|  if (nullptr != xml_output_file_env) {
  ------------------
  |  Branch (1380:7): [True: 0, False: 2]
  ------------------
 1381|      0|    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
 1382|      0|  }
 1383|      2|  return default_value_for_output_flag;
 1384|      2|}
_ZN7testing8internal18StringFromGTestEnvEPKcS2_:
 1388|     12|const char* StringFromGTestEnv(const char* flag, const char* default_value) {
 1389|       |#if defined(GTEST_GET_STRING_FROM_ENV_)
 1390|       |  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
 1391|       |#else
 1392|     12|  const std::string env_var = FlagToEnvVar(flag);
 1393|     12|  const char* const value = posix::GetEnv(env_var.c_str());
 1394|     12|  return value == nullptr ? default_value : value;
  ------------------
  |  Branch (1394:10): [True: 12, False: 0]
  ------------------
 1395|     12|#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
 1396|     12|}
gtest-port.cc:_ZN7testing8internalL12FlagToEnvVarEPKc:
 1274|     36|static std::string FlagToEnvVar(const char* flag) {
 1275|     36|  const std::string full_flag =
 1276|     36|      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
 1277|       |
 1278|     36|  Message env_var;
 1279|    728|  for (size_t i = 0; i != full_flag.length(); i++) {
  ------------------
  |  Branch (1279:22): [True: 692, False: 36]
  ------------------
 1280|    692|    env_var << ToUpper(full_flag.c_str()[i]);
 1281|    692|  }
 1282|       |
 1283|     36|  return env_var.GetString();
 1284|     36|}

_ZN7testing8internal13GetTestTypeIdEv:
  641|      2|TypeId GetTestTypeId() {
  642|      2|  return GetTypeId<Test>();
  643|      2|}
_ZN7testing7MessageC2Ev:
  964|     72|Message::Message() : ss_(new ::std::stringstream) {
  965|       |  // By default, we want there to be enough precision when printing
  966|       |  // a double to a Message.
  967|     72|  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
  968|     72|}
_ZNK7testing7Message9GetStringEv:
  990|     72|std::string Message::GetString() const {
  991|     72|  return internal::StringStreamToString(ss_.get());
  992|     72|}
_ZN7testing8internal20StringStreamToStringEPNSt3__118basic_stringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1993|     72|std::string StringStreamToString(::std::stringstream* ss) {
 1994|     72|  const ::std::string& str = ss->str();
 1995|     72|  const char* const start = str.c_str();
 1996|     72|  const char* const end = start + str.length();
 1997|       |
 1998|     72|  std::string result;
 1999|     72|  result.reserve(static_cast<size_t>(2 * (end - start)));
 2000|  1.45k|  for (const char* ch = start; ch != end; ++ch) {
  ------------------
  |  Branch (2000:32): [True: 1.38k, False: 72]
  ------------------
 2001|  1.38k|    if (*ch == '\0') {
  ------------------
  |  Branch (2001:9): [True: 0, False: 1.38k]
  ------------------
 2002|      0|      result += "\\0";  // Replaces NUL with "\\0";
 2003|  1.38k|    } else {
 2004|  1.38k|      result += *ch;
 2005|  1.38k|    }
 2006|  1.38k|  }
 2007|       |
 2008|     72|  return result;
 2009|     72|}
gtest.cc:_ZN7testingL16GetDefaultFilterEv:
  203|      2|static const char* GetDefaultFilter() {
  204|      2|  const char* const testbridge_test_only =
  205|      2|      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
  206|      2|  if (testbridge_test_only != nullptr) {
  ------------------
  |  Branch (206:7): [True: 0, False: 2]
  ------------------
  207|      0|    return testbridge_test_only;
  208|      0|  }
  209|      2|  return kUniversalFilter;
  210|      2|}

_ZN6google8protobuf8internal14ArenaStringPtr13MutableNoCopyEPNS0_5ArenaE:
  200|    954|std::string* ArenaStringPtr::MutableNoCopy(Arena* arena) {
  201|    954|  ScopedCheckPtrInvariants check(&tagged_ptr_);
  202|    954|  if (tagged_ptr_.IsMutable()) {
  ------------------
  |  Branch (202:7): [True: 0, False: 954]
  ------------------
  203|      0|    return tagged_ptr_.Get();
  204|    954|  } else {
  205|    954|    ABSL_DCHECK(IsDefault());
  ------------------
  |  |   43|    954|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|    954|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|    954|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|    954|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|    954|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|    954|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  206|       |    // Allocate empty. The contents are not relevant.
  207|    954|    return NewString(arena);
  208|    954|  }
  209|    954|}
_ZN6google8protobuf8internal14ArenaStringPtr7DestroyEv:
  255|  2.38k|void ArenaStringPtr::Destroy() {
  256|  2.38k|  delete tagged_ptr_.GetIfAllocated();
  257|  2.38k|}
arenastring.cc:_ZN6google8protobuf8internal12_GLOBAL__N_124ScopedCheckPtrInvariantsC2EPKNS1_15TaggedStringPtrE:
   93|    954|  explicit ScopedCheckPtrInvariants(const TaggedStringPtr*) {}

_ZN6google8protobuf14DescriptorPool24InternalAddGeneratedFileEPKvi:
 1977|     12|    const void* encoded_file_descriptor, int size) {
 1978|       |  // So, this function is called in the process of initializing the
 1979|       |  // descriptors for generated proto classes.  Each generated .pb.cc file
 1980|       |  // has an internal procedure called AddDescriptors() which is called at
 1981|       |  // process startup, and that function calls this one in order to register
 1982|       |  // the raw bytes of the FileDescriptorProto representing the file.
 1983|       |  //
 1984|       |  // We do not actually construct the descriptor objects right away.  We just
 1985|       |  // hang on to the bytes until they are actually needed.  We actually construct
 1986|       |  // the descriptor the first time one of the following things happens:
 1987|       |  // * Someone calls a method like descriptor(), GetDescriptor(), or
 1988|       |  //   GetReflection() on the generated types, which requires returning the
 1989|       |  //   descriptor or an object based on it.
 1990|       |  // * Someone looks up the descriptor in DescriptorPool::generated_pool().
 1991|       |  //
 1992|       |  // Once one of these happens, the DescriptorPool actually parses the
 1993|       |  // FileDescriptorProto and generates a FileDescriptor (and all its children)
 1994|       |  // based on it.
 1995|       |  //
 1996|       |  // Note that FileDescriptorProto is itself a generated protocol message.
 1997|       |  // Therefore, when we parse one, we have to be very careful to avoid using
 1998|       |  // any descriptor-based operations, since this might cause infinite recursion
 1999|       |  // or deadlock.
 2000|     12|  ABSL_CHECK(GeneratedDatabase()->Add(encoded_file_descriptor, size));
  ------------------
  |  |   40|     12|#define ABSL_CHECK(condition) ABSL_CHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   26|     12|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  157|     12|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  ------------------
  |  |  |  |   27|     12|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |   28|     12|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2001|     12|}
descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117GeneratedDatabaseEv:
 1941|     12|EncodedDescriptorDatabase* GeneratedDatabase() {
 1942|     12|  static auto generated_database =
 1943|     12|      internal::OnShutdownDelete(new EncodedDescriptorDatabase());
 1944|     12|  return generated_database;
 1945|     12|}

_ZN6google8protobuf19FileDescriptorProtoC2EPNS0_5ArenaE:
 2225|     12|    : ::google::protobuf::Message(arena) {
 2226|     12|  SharedCtor(arena);
 2227|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.FileDescriptorProto)
 2228|     12|}
_ZN6google8protobuf19FileDescriptorProtoD2Ev:
 2324|     12|FileDescriptorProto::~FileDescriptorProto() {
 2325|       |  // @@protoc_insertion_point(destructor:google.protobuf.FileDescriptorProto)
 2326|     12|  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
 2327|     12|  SharedDtor();
 2328|     12|}
_ZN6google8protobuf19FileDescriptorProto5ClearEv:
 2349|     12|PROTOBUF_NOINLINE void FileDescriptorProto::Clear() {
 2350|       |// @@protoc_insertion_point(message_clear_start:google.protobuf.FileDescriptorProto)
 2351|     12|  ::uint32_t cached_has_bits = 0;
 2352|       |  // Prevent compiler warnings about cached_has_bits being unused
 2353|     12|  (void) cached_has_bits;
 2354|       |
 2355|     12|  _internal_mutable_dependency()->Clear();
 2356|     12|  _internal_mutable_message_type()->Clear();
 2357|     12|  _internal_mutable_enum_type()->Clear();
 2358|     12|  _internal_mutable_service()->Clear();
 2359|     12|  _internal_mutable_extension()->Clear();
 2360|     12|  _internal_mutable_public_dependency()->Clear();
 2361|     12|  _internal_mutable_weak_dependency()->Clear();
 2362|     12|  cached_has_bits = _impl_._has_bits_[0];
 2363|     12|  if (cached_has_bits & 0x0000003fu) {
  ------------------
  |  Branch (2363:7): [True: 0, False: 12]
  ------------------
 2364|      0|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2364:9): [True: 0, False: 0]
  ------------------
 2365|      0|      _impl_.name_.ClearNonDefaultToEmpty();
 2366|      0|    }
 2367|      0|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2367:9): [True: 0, False: 0]
  ------------------
 2368|      0|      _impl_.package_.ClearNonDefaultToEmpty();
 2369|      0|    }
 2370|      0|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2370:9): [True: 0, False: 0]
  ------------------
 2371|      0|      _impl_.syntax_.ClearNonDefaultToEmpty();
 2372|      0|    }
 2373|      0|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (2373:9): [True: 0, False: 0]
  ------------------
 2374|      0|      _impl_.edition_.ClearNonDefaultToEmpty();
 2375|      0|    }
 2376|      0|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (2376:9): [True: 0, False: 0]
  ------------------
 2377|      0|      ABSL_DCHECK(_impl_.options_ != nullptr);
  ------------------
  |  |   43|      0|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|      0|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2378|      0|      _impl_.options_->Clear();
 2379|      0|    }
 2380|      0|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (2380:9): [True: 0, False: 0]
  ------------------
 2381|      0|      ABSL_DCHECK(_impl_.source_code_info_ != nullptr);
  ------------------
  |  |   43|      0|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|      0|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2382|      0|      _impl_.source_code_info_->Clear();
 2383|      0|    }
 2384|      0|  }
 2385|     12|  _impl_._has_bits_.Clear();
 2386|     12|  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
 2387|     12|}
_ZN6google8protobuf19FileDescriptorProto14_InternalParseEPKcPNS0_8internal12ParseContextE:
 2390|     12|    const char* ptr, ::_pbi::ParseContext* ctx) {
 2391|     12|  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
 2392|     12|  return ptr;
 2393|     12|}
_ZNK6google8protobuf19FileDescriptorProto13IsInitializedEv:
 2786|     12|PROTOBUF_NOINLINE bool FileDescriptorProto::IsInitialized() const {
 2787|     12|  if (!::google::protobuf::internal::AllAreInitialized(_internal_message_type()))
  ------------------
  |  Branch (2787:7): [True: 0, False: 12]
  ------------------
 2788|      0|    return false;
 2789|     12|  if (!::google::protobuf::internal::AllAreInitialized(_internal_enum_type()))
  ------------------
  |  Branch (2789:7): [True: 0, False: 12]
  ------------------
 2790|      0|    return false;
 2791|     12|  if (!::google::protobuf::internal::AllAreInitialized(_internal_service()))
  ------------------
  |  Branch (2791:7): [True: 0, False: 12]
  ------------------
 2792|      0|    return false;
 2793|     12|  if (!::google::protobuf::internal::AllAreInitialized(_internal_extension()))
  ------------------
  |  Branch (2793:7): [True: 0, False: 12]
  ------------------
 2794|      0|    return false;
 2795|     12|  if ((_impl_._has_bits_[0] & 0x00000010u) != 0) {
  ------------------
  |  Branch (2795:7): [True: 12, False: 0]
  ------------------
 2796|     12|    if (!_impl_.options_->IsInitialized()) return false;
  ------------------
  |  Branch (2796:9): [True: 0, False: 12]
  ------------------
 2797|     12|  }
 2798|     12|  return true;
 2799|     12|}
_ZN6google8protobuf30DescriptorProto_ExtensionRangeC2EPNS0_5ArenaE:
 2859|     18|    : ::google::protobuf::Message(arena) {
 2860|     18|  SharedCtor(arena);
 2861|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.DescriptorProto.ExtensionRange)
 2862|     18|}
_ZN6google8protobuf30DescriptorProto_ExtensionRangeD2Ev:
 2894|     18|DescriptorProto_ExtensionRange::~DescriptorProto_ExtensionRange() {
 2895|       |  // @@protoc_insertion_point(destructor:google.protobuf.DescriptorProto.ExtensionRange)
 2896|     18|  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
 2897|     18|  SharedDtor();
 2898|     18|}
_ZNK6google8protobuf30DescriptorProto_ExtensionRange13IsInitializedEv:
 3086|     18|PROTOBUF_NOINLINE bool DescriptorProto_ExtensionRange::IsInitialized() const {
 3087|     18|  if ((_impl_._has_bits_[0] & 0x00000001u) != 0) {
  ------------------
  |  Branch (3087:7): [True: 0, False: 18]
  ------------------
 3088|      0|    if (!_impl_.options_->IsInitialized()) return false;
  ------------------
  |  Branch (3088:9): [True: 0, False: 0]
  ------------------
 3089|      0|  }
 3090|     18|  return true;
 3091|     18|}
_ZN6google8protobuf29DescriptorProto_ReservedRangeC2EPNS0_5ArenaE:
 3126|     16|    : ::google::protobuf::Message(arena) {
 3127|     16|  SharedCtor(arena);
 3128|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.DescriptorProto.ReservedRange)
 3129|     16|}
_ZN6google8protobuf29DescriptorProto_ReservedRangeD2Ev:
 3145|     16|DescriptorProto_ReservedRange::~DescriptorProto_ReservedRange() {
 3146|       |  // @@protoc_insertion_point(destructor:google.protobuf.DescriptorProto.ReservedRange)
 3147|     16|  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
 3148|     16|  SharedDtor();
 3149|     16|}
_ZN6google8protobuf15DescriptorProtoC2EPNS0_5ArenaE:
 3348|     96|    : ::google::protobuf::Message(arena) {
 3349|     96|  SharedCtor(arena);
 3350|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.DescriptorProto)
 3351|     96|}
_ZN6google8protobuf15DescriptorProtoD2Ev:
 3405|     96|DescriptorProto::~DescriptorProto() {
 3406|       |  // @@protoc_insertion_point(destructor:google.protobuf.DescriptorProto)
 3407|     96|  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
 3408|     96|  SharedDtor();
 3409|     96|}
_ZNK6google8protobuf15DescriptorProto13IsInitializedEv:
 3776|     96|PROTOBUF_NOINLINE bool DescriptorProto::IsInitialized() const {
 3777|     96|  if (!::google::protobuf::internal::AllAreInitialized(_internal_field()))
  ------------------
  |  Branch (3777:7): [True: 0, False: 96]
  ------------------
 3778|      0|    return false;
 3779|     96|  if (!::google::protobuf::internal::AllAreInitialized(_internal_nested_type()))
  ------------------
  |  Branch (3779:7): [True: 0, False: 96]
  ------------------
 3780|      0|    return false;
 3781|     96|  if (!::google::protobuf::internal::AllAreInitialized(_internal_enum_type()))
  ------------------
  |  Branch (3781:7): [True: 0, False: 96]
  ------------------
 3782|      0|    return false;
 3783|     96|  if (!::google::protobuf::internal::AllAreInitialized(_internal_extension_range()))
  ------------------
  |  Branch (3783:7): [True: 0, False: 96]
  ------------------
 3784|      0|    return false;
 3785|     96|  if (!::google::protobuf::internal::AllAreInitialized(_internal_extension()))
  ------------------
  |  Branch (3785:7): [True: 0, False: 96]
  ------------------
 3786|      0|    return false;
 3787|     96|  if (!::google::protobuf::internal::AllAreInitialized(_internal_oneof_decl()))
  ------------------
  |  Branch (3787:7): [True: 0, False: 96]
  ------------------
 3788|      0|    return false;
 3789|     96|  if ((_impl_._has_bits_[0] & 0x00000002u) != 0) {
  ------------------
  |  Branch (3789:7): [True: 2, False: 94]
  ------------------
 3790|      2|    if (!_impl_.options_->IsInitialized()) return false;
  ------------------
  |  Branch (3790:9): [True: 0, False: 2]
  ------------------
 3791|      2|  }
 3792|     96|  return true;
 3793|     96|}
_ZN6google8protobuf20FieldDescriptorProtoC2EPNS0_5ArenaE:
 4502|    386|    : ::google::protobuf::Message(arena) {
 4503|    386|  SharedCtor(arena);
 4504|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.FieldDescriptorProto)
 4505|    386|}
_ZN6google8protobuf20FieldDescriptorProtoD2Ev:
 4608|    386|FieldDescriptorProto::~FieldDescriptorProto() {
 4609|       |  // @@protoc_insertion_point(destructor:google.protobuf.FieldDescriptorProto)
 4610|    386|  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
 4611|    386|  SharedDtor();
 4612|    386|}
_ZNK6google8protobuf20FieldDescriptorProto13IsInitializedEv:
 5023|    386|PROTOBUF_NOINLINE bool FieldDescriptorProto::IsInitialized() const {
 5024|    386|  if ((_impl_._has_bits_[0] & 0x00000020u) != 0) {
  ------------------
  |  Branch (5024:7): [True: 18, False: 368]
  ------------------
 5025|     18|    if (!_impl_.options_->IsInitialized()) return false;
  ------------------
  |  Branch (5025:9): [True: 0, False: 18]
  ------------------
 5026|     18|  }
 5027|    386|  return true;
 5028|    386|}
_ZN6google8protobuf20OneofDescriptorProtoC2EPNS0_5ArenaE:
 5079|      2|    : ::google::protobuf::Message(arena) {
 5080|      2|  SharedCtor(arena);
 5081|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.OneofDescriptorProto)
 5082|      2|}
_ZN6google8protobuf20OneofDescriptorProtoD2Ev:
 5120|      2|OneofDescriptorProto::~OneofDescriptorProto() {
 5121|       |  // @@protoc_insertion_point(destructor:google.protobuf.OneofDescriptorProto)
 5122|      2|  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
 5123|      2|  SharedDtor();
 5124|      2|}
_ZNK6google8protobuf20OneofDescriptorProto13IsInitializedEv:
 5293|      2|PROTOBUF_NOINLINE bool OneofDescriptorProto::IsInitialized() const {
 5294|      2|  if ((_impl_._has_bits_[0] & 0x00000002u) != 0) {
  ------------------
  |  Branch (5294:7): [True: 0, False: 2]
  ------------------
 5295|      0|    if (!_impl_.options_->IsInitialized()) return false;
  ------------------
  |  Branch (5295:9): [True: 0, False: 0]
  ------------------
 5296|      0|  }
 5297|      2|  return true;
 5298|      2|}
_ZN6google8protobuf19EnumDescriptorProtoC2EPNS0_5ArenaE:
 5554|     28|    : ::google::protobuf::Message(arena) {
 5555|     28|  SharedCtor(arena);
 5556|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.EnumDescriptorProto)
 5557|     28|}
_ZN6google8protobuf19EnumDescriptorProtoD2Ev:
 5601|     28|EnumDescriptorProto::~EnumDescriptorProto() {
 5602|       |  // @@protoc_insertion_point(destructor:google.protobuf.EnumDescriptorProto)
 5603|     28|  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
 5604|     28|  SharedDtor();
 5605|     28|}
_ZNK6google8protobuf19EnumDescriptorProto13IsInitializedEv:
 5849|     28|PROTOBUF_NOINLINE bool EnumDescriptorProto::IsInitialized() const {
 5850|     28|  if (!::google::protobuf::internal::AllAreInitialized(_internal_value()))
  ------------------
  |  Branch (5850:7): [True: 0, False: 28]
  ------------------
 5851|      0|    return false;
 5852|     28|  if ((_impl_._has_bits_[0] & 0x00000002u) != 0) {
  ------------------
  |  Branch (5852:7): [True: 0, False: 28]
  ------------------
 5853|      0|    if (!_impl_.options_->IsInitialized()) return false;
  ------------------
  |  Branch (5853:9): [True: 0, False: 0]
  ------------------
 5854|      0|  }
 5855|     28|  return true;
 5856|     28|}
_ZN6google8protobuf24EnumValueDescriptorProtoC2EPNS0_5ArenaE:
 5901|    156|    : ::google::protobuf::Message(arena) {
 5902|    156|  SharedCtor(arena);
 5903|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.EnumValueDescriptorProto)
 5904|    156|}
_ZN6google8protobuf24EnumValueDescriptorProtoD2Ev:
 5945|    156|EnumValueDescriptorProto::~EnumValueDescriptorProto() {
 5946|       |  // @@protoc_insertion_point(destructor:google.protobuf.EnumValueDescriptorProto)
 5947|    156|  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
 5948|    156|  SharedDtor();
 5949|    156|}
_ZNK6google8protobuf24EnumValueDescriptorProto13IsInitializedEv:
 6143|    156|PROTOBUF_NOINLINE bool EnumValueDescriptorProto::IsInitialized() const {
 6144|    156|  if ((_impl_._has_bits_[0] & 0x00000002u) != 0) {
  ------------------
  |  Branch (6144:7): [True: 0, False: 156]
  ------------------
 6145|      0|    if (!_impl_.options_->IsInitialized()) return false;
  ------------------
  |  Branch (6145:9): [True: 0, False: 0]
  ------------------
 6146|      0|  }
 6147|    156|  return true;
 6148|    156|}
_ZN6google8protobuf11FileOptionsC2EPNS0_5ArenaE:
 6943|     12|    : ::google::protobuf::Message(arena) {
 6944|     12|  SharedCtor(arena);
 6945|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.FileOptions)
 6946|     12|}
_ZN6google8protobuf11FileOptionsD2Ev:
 7125|     12|FileOptions::~FileOptions() {
 7126|       |  // @@protoc_insertion_point(destructor:google.protobuf.FileOptions)
 7127|     12|  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
 7128|     12|  SharedDtor();
 7129|     12|}
_ZNK6google8protobuf11FileOptions13IsInitializedEv:
 7796|     12|PROTOBUF_NOINLINE bool FileOptions::IsInitialized() const {
 7797|     12|  if (!_impl_._extensions_.IsInitialized(internal_default_instance())) {
  ------------------
  |  Branch (7797:7): [True: 0, False: 12]
  ------------------
 7798|      0|    return false;
 7799|      0|  }
 7800|     12|  if (!::google::protobuf::internal::AllAreInitialized(_internal_uninterpreted_option()))
  ------------------
  |  Branch (7800:7): [True: 0, False: 12]
  ------------------
 7801|      0|    return false;
 7802|     12|  return true;
 7803|     12|}
_ZN6google8protobuf14MessageOptionsC2EPNS0_5ArenaE:
 7871|      2|    : ::google::protobuf::Message(arena) {
 7872|      2|  SharedCtor(arena);
 7873|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.MessageOptions)
 7874|      2|}
_ZN6google8protobuf14MessageOptionsD2Ev:
 7913|      2|MessageOptions::~MessageOptions() {
 7914|       |  // @@protoc_insertion_point(destructor:google.protobuf.MessageOptions)
 7915|      2|  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
 7916|      2|  SharedDtor();
 7917|      2|}
_ZNK6google8protobuf14MessageOptions13IsInitializedEv:
 8167|      2|PROTOBUF_NOINLINE bool MessageOptions::IsInitialized() const {
 8168|      2|  if (!_impl_._extensions_.IsInitialized(internal_default_instance())) {
  ------------------
  |  Branch (8168:7): [True: 0, False: 2]
  ------------------
 8169|      0|    return false;
 8170|      0|  }
 8171|      2|  if (!::google::protobuf::internal::AllAreInitialized(_internal_uninterpreted_option()))
  ------------------
  |  Branch (8171:7): [True: 0, False: 2]
  ------------------
 8172|      0|    return false;
 8173|      2|  return true;
 8174|      2|}
_ZN6google8protobuf12FieldOptionsC2EPNS0_5ArenaE:
 8235|     18|    : ::google::protobuf::Message(arena) {
 8236|     18|  SharedCtor(arena);
 8237|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.FieldOptions)
 8238|     18|}
_ZN6google8protobuf12FieldOptionsD2Ev:
 8289|     18|FieldOptions::~FieldOptions() {
 8290|       |  // @@protoc_insertion_point(destructor:google.protobuf.FieldOptions)
 8291|     18|  _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
 8292|     18|  SharedDtor();
 8293|     18|}
_ZNK6google8protobuf12FieldOptions13IsInitializedEv:
 8696|     18|PROTOBUF_NOINLINE bool FieldOptions::IsInitialized() const {
 8697|     18|  if (!_impl_._extensions_.IsInitialized(internal_default_instance())) {
  ------------------
  |  Branch (8697:7): [True: 0, False: 18]
  ------------------
 8698|      0|    return false;
 8699|      0|  }
 8700|     18|  if (!::google::protobuf::internal::AllAreInitialized(_internal_uninterpreted_option()))
  ------------------
  |  Branch (8700:7): [True: 0, False: 18]
  ------------------
 8701|      0|    return false;
 8702|     18|  return true;
 8703|     18|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_30DescriptorProto_ExtensionRangeEJEEEPT_PS1_DpOT0_:
11728|     18|Arena::CreateMaybeMessage< ::google::protobuf::DescriptorProto_ExtensionRange >(Arena* arena) {
11729|     18|  return Arena::CreateMessageInternal< ::google::protobuf::DescriptorProto_ExtensionRange >(arena);
11730|     18|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_29DescriptorProto_ReservedRangeEJEEEPT_PS1_DpOT0_:
11732|     16|Arena::CreateMaybeMessage< ::google::protobuf::DescriptorProto_ReservedRange >(Arena* arena) {
11733|     16|  return Arena::CreateMessageInternal< ::google::protobuf::DescriptorProto_ReservedRange >(arena);
11734|     16|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_15DescriptorProtoEJEEEPT_PS1_DpOT0_:
11736|     96|Arena::CreateMaybeMessage< ::google::protobuf::DescriptorProto >(Arena* arena) {
11737|     96|  return Arena::CreateMessageInternal< ::google::protobuf::DescriptorProto >(arena);
11738|     96|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_20FieldDescriptorProtoEJEEEPT_PS1_DpOT0_:
11748|    386|Arena::CreateMaybeMessage< ::google::protobuf::FieldDescriptorProto >(Arena* arena) {
11749|    386|  return Arena::CreateMessageInternal< ::google::protobuf::FieldDescriptorProto >(arena);
11750|    386|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_20OneofDescriptorProtoEJEEEPT_PS1_DpOT0_:
11752|      2|Arena::CreateMaybeMessage< ::google::protobuf::OneofDescriptorProto >(Arena* arena) {
11753|      2|  return Arena::CreateMessageInternal< ::google::protobuf::OneofDescriptorProto >(arena);
11754|      2|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_19EnumDescriptorProtoEJEEEPT_PS1_DpOT0_:
11760|     28|Arena::CreateMaybeMessage< ::google::protobuf::EnumDescriptorProto >(Arena* arena) {
11761|     28|  return Arena::CreateMessageInternal< ::google::protobuf::EnumDescriptorProto >(arena);
11762|     28|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_24EnumValueDescriptorProtoEJEEEPT_PS1_DpOT0_:
11764|    156|Arena::CreateMaybeMessage< ::google::protobuf::EnumValueDescriptorProto >(Arena* arena) {
11765|    156|  return Arena::CreateMessageInternal< ::google::protobuf::EnumValueDescriptorProto >(arena);
11766|    156|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_11FileOptionsEJEEEPT_PS1_DpOT0_:
11776|     12|Arena::CreateMaybeMessage< ::google::protobuf::FileOptions >(Arena* arena) {
11777|     12|  return Arena::CreateMessageInternal< ::google::protobuf::FileOptions >(arena);
11778|     12|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_14MessageOptionsEJEEEPT_PS1_DpOT0_:
11780|      2|Arena::CreateMaybeMessage< ::google::protobuf::MessageOptions >(Arena* arena) {
11781|      2|  return Arena::CreateMessageInternal< ::google::protobuf::MessageOptions >(arena);
11782|      2|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_12FieldOptionsEJEEEPT_PS1_DpOT0_:
11784|     18|Arena::CreateMaybeMessage< ::google::protobuf::FieldOptions >(Arena* arena) {
11785|     18|  return Arena::CreateMessageInternal< ::google::protobuf::FieldOptions >(arena);
11786|     18|}
_ZN6google8protobuf19FileDescriptorProto10SharedCtorEPNS0_5ArenaE:
 2288|     12|inline void FileDescriptorProto::SharedCtor(::_pb::Arena* arena) {
 2289|     12|  (void)arena;
 2290|     12|  new (&_impl_) Impl_{
 2291|     12|      decltype(_impl_._has_bits_){},
 2292|     12|      /*decltype(_impl_._cached_size_)*/ {},
 2293|     12|      decltype(_impl_.dependency_){arena},
 2294|     12|      decltype(_impl_.message_type_){arena},
 2295|     12|      decltype(_impl_.enum_type_){arena},
 2296|     12|      decltype(_impl_.service_){arena},
 2297|     12|      decltype(_impl_.extension_){arena},
 2298|     12|      decltype(_impl_.public_dependency_){arena},
 2299|     12|      decltype(_impl_.weak_dependency_){arena},
 2300|     12|      decltype(_impl_.name_){},
 2301|     12|      decltype(_impl_.package_){},
 2302|     12|      decltype(_impl_.syntax_){},
 2303|     12|      decltype(_impl_.edition_){},
 2304|     12|      decltype(_impl_.options_){nullptr},
 2305|     12|      decltype(_impl_.source_code_info_){nullptr},
 2306|     12|  };
 2307|     12|  _impl_.name_.InitDefault();
 2308|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2309|       |        _impl_.name_.Set("", GetArenaForAllocation());
 2310|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2311|     12|  _impl_.package_.InitDefault();
 2312|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2313|       |        _impl_.package_.Set("", GetArenaForAllocation());
 2314|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2315|     12|  _impl_.syntax_.InitDefault();
 2316|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2317|       |        _impl_.syntax_.Set("", GetArenaForAllocation());
 2318|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2319|     12|  _impl_.edition_.InitDefault();
 2320|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2321|       |        _impl_.edition_.Set("", GetArenaForAllocation());
 2322|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2323|     12|}
_ZN6google8protobuf19FileDescriptorProto10SharedDtorEv:
 2329|     12|inline void FileDescriptorProto::SharedDtor() {
 2330|     12|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|     12|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     12|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     12|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     12|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     12|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     12|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2331|     12|  _internal_mutable_dependency()->~RepeatedPtrField();
 2332|     12|  _impl_.message_type_.~RepeatedPtrField();
 2333|     12|  _impl_.enum_type_.~RepeatedPtrField();
 2334|     12|  _impl_.service_.~RepeatedPtrField();
 2335|     12|  _impl_.extension_.~RepeatedPtrField();
 2336|     12|  _impl_.public_dependency_.~RepeatedField();
 2337|     12|  _impl_.weak_dependency_.~RepeatedField();
 2338|     12|  _impl_.name_.Destroy();
 2339|     12|  _impl_.package_.Destroy();
 2340|     12|  _impl_.syntax_.Destroy();
 2341|     12|  _impl_.edition_.Destroy();
 2342|     12|  if (this != internal_default_instance()) delete _impl_.options_;
  ------------------
  |  Branch (2342:7): [True: 12, False: 0]
  ------------------
 2343|     12|  if (this != internal_default_instance()) delete _impl_.source_code_info_;
  ------------------
  |  Branch (2343:7): [True: 12, False: 0]
  ------------------
 2344|     12|}
_ZN6google8protobuf30DescriptorProto_ExtensionRange10SharedCtorEPNS0_5ArenaE:
 2884|     18|inline void DescriptorProto_ExtensionRange::SharedCtor(::_pb::Arena* arena) {
 2885|     18|  (void)arena;
 2886|     18|  new (&_impl_) Impl_{
 2887|     18|      decltype(_impl_._has_bits_){},
 2888|     18|      /*decltype(_impl_._cached_size_)*/ {},
 2889|     18|      decltype(_impl_.options_){nullptr},
 2890|     18|      decltype(_impl_.start_){0},
 2891|     18|      decltype(_impl_.end_){0},
 2892|     18|  };
 2893|     18|}
_ZN6google8protobuf30DescriptorProto_ExtensionRange10SharedDtorEv:
 2899|     18|inline void DescriptorProto_ExtensionRange::SharedDtor() {
 2900|     18|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|     18|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     18|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     18|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     18|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     18|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     18|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2901|     18|  if (this != internal_default_instance()) delete _impl_.options_;
  ------------------
  |  Branch (2901:7): [True: 18, False: 0]
  ------------------
 2902|     18|}
_ZN6google8protobuf29DescriptorProto_ReservedRange10SharedCtorEPNS0_5ArenaE:
 3136|     16|inline void DescriptorProto_ReservedRange::SharedCtor(::_pb::Arena* arena) {
 3137|     16|  (void)arena;
 3138|     16|  new (&_impl_) Impl_{
 3139|     16|      decltype(_impl_._has_bits_){},
 3140|     16|      /*decltype(_impl_._cached_size_)*/ {},
 3141|     16|      decltype(_impl_.start_){0},
 3142|     16|      decltype(_impl_.end_){0},
 3143|     16|  };
 3144|     16|}
_ZN6google8protobuf29DescriptorProto_ReservedRange10SharedDtorEv:
 3150|     16|inline void DescriptorProto_ReservedRange::SharedDtor() {
 3151|     16|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|     16|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     16|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     16|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     16|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     16|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     16|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3152|     16|}
_ZN6google8protobuf15DescriptorProto10SharedCtorEPNS0_5ArenaE:
 3384|     96|inline void DescriptorProto::SharedCtor(::_pb::Arena* arena) {
 3385|     96|  (void)arena;
 3386|     96|  new (&_impl_) Impl_{
 3387|     96|      decltype(_impl_._has_bits_){},
 3388|     96|      /*decltype(_impl_._cached_size_)*/ {},
 3389|     96|      decltype(_impl_.field_){arena},
 3390|     96|      decltype(_impl_.nested_type_){arena},
 3391|     96|      decltype(_impl_.enum_type_){arena},
 3392|     96|      decltype(_impl_.extension_range_){arena},
 3393|     96|      decltype(_impl_.extension_){arena},
 3394|     96|      decltype(_impl_.oneof_decl_){arena},
 3395|     96|      decltype(_impl_.reserved_range_){arena},
 3396|     96|      decltype(_impl_.reserved_name_){arena},
 3397|     96|      decltype(_impl_.name_){},
 3398|     96|      decltype(_impl_.options_){nullptr},
 3399|     96|  };
 3400|     96|  _impl_.name_.InitDefault();
 3401|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 3402|       |        _impl_.name_.Set("", GetArenaForAllocation());
 3403|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 3404|     96|}
_ZN6google8protobuf15DescriptorProto10SharedDtorEv:
 3410|     96|inline void DescriptorProto::SharedDtor() {
 3411|     96|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|     96|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     96|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     96|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     96|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     96|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     96|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3412|     96|  _impl_.field_.~RepeatedPtrField();
 3413|     96|  _impl_.nested_type_.~RepeatedPtrField();
 3414|     96|  _impl_.enum_type_.~RepeatedPtrField();
 3415|     96|  _impl_.extension_range_.~RepeatedPtrField();
 3416|     96|  _impl_.extension_.~RepeatedPtrField();
 3417|     96|  _impl_.oneof_decl_.~RepeatedPtrField();
 3418|     96|  _impl_.reserved_range_.~RepeatedPtrField();
 3419|     96|  _internal_mutable_reserved_name()->~RepeatedPtrField();
 3420|     96|  _impl_.name_.Destroy();
 3421|     96|  if (this != internal_default_instance()) delete _impl_.options_;
  ------------------
  |  Branch (3421:7): [True: 96, False: 0]
  ------------------
 3422|     96|}
_ZN6google8protobuf20FieldDescriptorProto10SharedCtorEPNS0_5ArenaE:
 4570|    386|inline void FieldDescriptorProto::SharedCtor(::_pb::Arena* arena) {
 4571|    386|  (void)arena;
 4572|    386|  new (&_impl_) Impl_{
 4573|    386|      decltype(_impl_._has_bits_){},
 4574|    386|      /*decltype(_impl_._cached_size_)*/ {},
 4575|    386|      decltype(_impl_.name_){},
 4576|    386|      decltype(_impl_.extendee_){},
 4577|    386|      decltype(_impl_.type_name_){},
 4578|    386|      decltype(_impl_.default_value_){},
 4579|    386|      decltype(_impl_.json_name_){},
 4580|    386|      decltype(_impl_.options_){nullptr},
 4581|    386|      decltype(_impl_.number_){0},
 4582|    386|      decltype(_impl_.oneof_index_){0},
 4583|    386|      decltype(_impl_.proto3_optional_){false},
 4584|    386|      decltype(_impl_.label_){1},
 4585|    386|      decltype(_impl_.type_){1},
 4586|    386|  };
 4587|    386|  _impl_.name_.InitDefault();
 4588|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4589|       |        _impl_.name_.Set("", GetArenaForAllocation());
 4590|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4591|    386|  _impl_.extendee_.InitDefault();
 4592|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4593|       |        _impl_.extendee_.Set("", GetArenaForAllocation());
 4594|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4595|    386|  _impl_.type_name_.InitDefault();
 4596|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4597|       |        _impl_.type_name_.Set("", GetArenaForAllocation());
 4598|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4599|    386|  _impl_.default_value_.InitDefault();
 4600|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4601|       |        _impl_.default_value_.Set("", GetArenaForAllocation());
 4602|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4603|    386|  _impl_.json_name_.InitDefault();
 4604|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4605|       |        _impl_.json_name_.Set("", GetArenaForAllocation());
 4606|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4607|    386|}
_ZN6google8protobuf20FieldDescriptorProto10SharedDtorEv:
 4613|    386|inline void FieldDescriptorProto::SharedDtor() {
 4614|    386|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|    386|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|    386|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|    386|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|    386|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|    386|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|    386|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4615|    386|  _impl_.name_.Destroy();
 4616|    386|  _impl_.extendee_.Destroy();
 4617|    386|  _impl_.type_name_.Destroy();
 4618|    386|  _impl_.default_value_.Destroy();
 4619|    386|  _impl_.json_name_.Destroy();
 4620|    386|  if (this != internal_default_instance()) delete _impl_.options_;
  ------------------
  |  Branch (4620:7): [True: 386, False: 0]
  ------------------
 4621|    386|}
_ZN6google8protobuf20OneofDescriptorProto10SharedCtorEPNS0_5ArenaE:
 5107|      2|inline void OneofDescriptorProto::SharedCtor(::_pb::Arena* arena) {
 5108|      2|  (void)arena;
 5109|      2|  new (&_impl_) Impl_{
 5110|      2|      decltype(_impl_._has_bits_){},
 5111|      2|      /*decltype(_impl_._cached_size_)*/ {},
 5112|      2|      decltype(_impl_.name_){},
 5113|      2|      decltype(_impl_.options_){nullptr},
 5114|      2|  };
 5115|      2|  _impl_.name_.InitDefault();
 5116|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 5117|       |        _impl_.name_.Set("", GetArenaForAllocation());
 5118|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 5119|      2|}
_ZN6google8protobuf20OneofDescriptorProto10SharedDtorEv:
 5125|      2|inline void OneofDescriptorProto::SharedDtor() {
 5126|      2|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|      2|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|      2|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|      2|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      2|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 5127|      2|  _impl_.name_.Destroy();
 5128|      2|  if (this != internal_default_instance()) delete _impl_.options_;
  ------------------
  |  Branch (5128:7): [True: 2, False: 0]
  ------------------
 5129|      2|}
_ZN6google8protobuf19EnumDescriptorProto10SharedCtorEPNS0_5ArenaE:
 5585|     28|inline void EnumDescriptorProto::SharedCtor(::_pb::Arena* arena) {
 5586|     28|  (void)arena;
 5587|     28|  new (&_impl_) Impl_{
 5588|     28|      decltype(_impl_._has_bits_){},
 5589|     28|      /*decltype(_impl_._cached_size_)*/ {},
 5590|     28|      decltype(_impl_.value_){arena},
 5591|     28|      decltype(_impl_.reserved_range_){arena},
 5592|     28|      decltype(_impl_.reserved_name_){arena},
 5593|     28|      decltype(_impl_.name_){},
 5594|     28|      decltype(_impl_.options_){nullptr},
 5595|     28|  };
 5596|     28|  _impl_.name_.InitDefault();
 5597|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 5598|       |        _impl_.name_.Set("", GetArenaForAllocation());
 5599|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 5600|     28|}
_ZN6google8protobuf19EnumDescriptorProto10SharedDtorEv:
 5606|     28|inline void EnumDescriptorProto::SharedDtor() {
 5607|     28|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|     28|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     28|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     28|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     28|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     28|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     28|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 5608|     28|  _impl_.value_.~RepeatedPtrField();
 5609|     28|  _impl_.reserved_range_.~RepeatedPtrField();
 5610|     28|  _internal_mutable_reserved_name()->~RepeatedPtrField();
 5611|     28|  _impl_.name_.Destroy();
 5612|     28|  if (this != internal_default_instance()) delete _impl_.options_;
  ------------------
  |  Branch (5612:7): [True: 28, False: 0]
  ------------------
 5613|     28|}
_ZN6google8protobuf24EnumValueDescriptorProto10SharedCtorEPNS0_5ArenaE:
 5931|    156|inline void EnumValueDescriptorProto::SharedCtor(::_pb::Arena* arena) {
 5932|    156|  (void)arena;
 5933|    156|  new (&_impl_) Impl_{
 5934|    156|      decltype(_impl_._has_bits_){},
 5935|    156|      /*decltype(_impl_._cached_size_)*/ {},
 5936|    156|      decltype(_impl_.name_){},
 5937|    156|      decltype(_impl_.options_){nullptr},
 5938|    156|      decltype(_impl_.number_){0},
 5939|    156|  };
 5940|    156|  _impl_.name_.InitDefault();
 5941|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 5942|       |        _impl_.name_.Set("", GetArenaForAllocation());
 5943|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 5944|    156|}
_ZN6google8protobuf24EnumValueDescriptorProto10SharedDtorEv:
 5950|    156|inline void EnumValueDescriptorProto::SharedDtor() {
 5951|    156|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|    156|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|    156|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|    156|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|    156|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|    156|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|    156|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 5952|    156|  _impl_.name_.Destroy();
 5953|    156|  if (this != internal_default_instance()) delete _impl_.options_;
  ------------------
  |  Branch (5953:7): [True: 156, False: 0]
  ------------------
 5954|    156|}
_ZN6google8protobuf11FileOptions10SharedCtorEPNS0_5ArenaE:
 7056|     12|inline void FileOptions::SharedCtor(::_pb::Arena* arena) {
 7057|     12|  (void)arena;
 7058|     12|  new (&_impl_) Impl_{
 7059|     12|      /*decltype(_impl_._extensions_)*/ {::_pbi::ArenaInitialized(), arena},
 7060|     12|      decltype(_impl_._has_bits_){},
 7061|     12|      /*decltype(_impl_._cached_size_)*/ {},
 7062|     12|      decltype(_impl_.uninterpreted_option_){arena},
 7063|     12|      decltype(_impl_.java_package_){},
 7064|     12|      decltype(_impl_.java_outer_classname_){},
 7065|     12|      decltype(_impl_.go_package_){},
 7066|     12|      decltype(_impl_.objc_class_prefix_){},
 7067|     12|      decltype(_impl_.csharp_namespace_){},
 7068|     12|      decltype(_impl_.swift_prefix_){},
 7069|     12|      decltype(_impl_.php_class_prefix_){},
 7070|     12|      decltype(_impl_.php_namespace_){},
 7071|     12|      decltype(_impl_.php_metadata_namespace_){},
 7072|     12|      decltype(_impl_.ruby_package_){},
 7073|     12|      decltype(_impl_.java_multiple_files_){false},
 7074|     12|      decltype(_impl_.java_generate_equals_and_hash_){false},
 7075|     12|      decltype(_impl_.java_string_check_utf8_){false},
 7076|     12|      decltype(_impl_.cc_generic_services_){false},
 7077|     12|      decltype(_impl_.java_generic_services_){false},
 7078|     12|      decltype(_impl_.py_generic_services_){false},
 7079|     12|      decltype(_impl_.php_generic_services_){false},
 7080|     12|      decltype(_impl_.deprecated_){false},
 7081|     12|      decltype(_impl_.optimize_for_){1},
 7082|     12|      decltype(_impl_.cc_enable_arenas_){true},
 7083|     12|  };
 7084|     12|  _impl_.java_package_.InitDefault();
 7085|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7086|       |        _impl_.java_package_.Set("", GetArenaForAllocation());
 7087|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7088|     12|  _impl_.java_outer_classname_.InitDefault();
 7089|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7090|       |        _impl_.java_outer_classname_.Set("", GetArenaForAllocation());
 7091|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7092|     12|  _impl_.go_package_.InitDefault();
 7093|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7094|       |        _impl_.go_package_.Set("", GetArenaForAllocation());
 7095|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7096|     12|  _impl_.objc_class_prefix_.InitDefault();
 7097|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7098|       |        _impl_.objc_class_prefix_.Set("", GetArenaForAllocation());
 7099|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7100|     12|  _impl_.csharp_namespace_.InitDefault();
 7101|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7102|       |        _impl_.csharp_namespace_.Set("", GetArenaForAllocation());
 7103|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7104|     12|  _impl_.swift_prefix_.InitDefault();
 7105|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7106|       |        _impl_.swift_prefix_.Set("", GetArenaForAllocation());
 7107|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7108|     12|  _impl_.php_class_prefix_.InitDefault();
 7109|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7110|       |        _impl_.php_class_prefix_.Set("", GetArenaForAllocation());
 7111|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7112|     12|  _impl_.php_namespace_.InitDefault();
 7113|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7114|       |        _impl_.php_namespace_.Set("", GetArenaForAllocation());
 7115|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7116|     12|  _impl_.php_metadata_namespace_.InitDefault();
 7117|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7118|       |        _impl_.php_metadata_namespace_.Set("", GetArenaForAllocation());
 7119|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7120|     12|  _impl_.ruby_package_.InitDefault();
 7121|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7122|       |        _impl_.ruby_package_.Set("", GetArenaForAllocation());
 7123|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7124|     12|}
_ZN6google8protobuf11FileOptions10SharedDtorEv:
 7130|     12|inline void FileOptions::SharedDtor() {
 7131|     12|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|     12|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     12|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     12|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     12|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     12|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     12|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7132|     12|  _impl_._extensions_.~ExtensionSet();
 7133|     12|  _impl_.uninterpreted_option_.~RepeatedPtrField();
 7134|     12|  _impl_.java_package_.Destroy();
 7135|     12|  _impl_.java_outer_classname_.Destroy();
 7136|     12|  _impl_.go_package_.Destroy();
 7137|     12|  _impl_.objc_class_prefix_.Destroy();
 7138|     12|  _impl_.csharp_namespace_.Destroy();
 7139|     12|  _impl_.swift_prefix_.Destroy();
 7140|     12|  _impl_.php_class_prefix_.Destroy();
 7141|     12|  _impl_.php_namespace_.Destroy();
 7142|     12|  _impl_.php_metadata_namespace_.Destroy();
 7143|     12|  _impl_.ruby_package_.Destroy();
 7144|     12|}
_ZN6google8protobuf14MessageOptions10SharedCtorEPNS0_5ArenaE:
 7899|      2|inline void MessageOptions::SharedCtor(::_pb::Arena* arena) {
 7900|      2|  (void)arena;
 7901|      2|  new (&_impl_) Impl_{
 7902|      2|      /*decltype(_impl_._extensions_)*/ {::_pbi::ArenaInitialized(), arena},
 7903|      2|      decltype(_impl_._has_bits_){},
 7904|      2|      /*decltype(_impl_._cached_size_)*/ {},
 7905|      2|      decltype(_impl_.uninterpreted_option_){arena},
 7906|      2|      decltype(_impl_.message_set_wire_format_){false},
 7907|      2|      decltype(_impl_.no_standard_descriptor_accessor_){false},
 7908|      2|      decltype(_impl_.deprecated_){false},
 7909|      2|      decltype(_impl_.map_entry_){false},
 7910|      2|      decltype(_impl_.deprecated_legacy_json_field_conflicts_){false},
 7911|      2|  };
 7912|      2|}
_ZN6google8protobuf14MessageOptions10SharedDtorEv:
 7918|      2|inline void MessageOptions::SharedDtor() {
 7919|      2|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|      2|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|      2|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|      2|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      2|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7920|      2|  _impl_._extensions_.~ExtensionSet();
 7921|      2|  _impl_.uninterpreted_option_.~RepeatedPtrField();
 7922|      2|}
_ZN6google8protobuf12FieldOptions10SharedCtorEPNS0_5ArenaE:
 8269|     18|inline void FieldOptions::SharedCtor(::_pb::Arena* arena) {
 8270|     18|  (void)arena;
 8271|     18|  new (&_impl_) Impl_{
 8272|     18|      /*decltype(_impl_._extensions_)*/ {::_pbi::ArenaInitialized(), arena},
 8273|     18|      decltype(_impl_._has_bits_){},
 8274|     18|      /*decltype(_impl_._cached_size_)*/ {},
 8275|     18|      decltype(_impl_.targets_){arena},
 8276|     18|      decltype(_impl_.uninterpreted_option_){arena},
 8277|     18|      decltype(_impl_.ctype_){0},
 8278|     18|      decltype(_impl_.jstype_){0},
 8279|     18|      decltype(_impl_.packed_){false},
 8280|     18|      decltype(_impl_.lazy_){false},
 8281|     18|      decltype(_impl_.unverified_lazy_){false},
 8282|     18|      decltype(_impl_.deprecated_){false},
 8283|     18|      decltype(_impl_.weak_){false},
 8284|     18|      decltype(_impl_.debug_redact_){false},
 8285|     18|      decltype(_impl_.retention_){0},
 8286|     18|      decltype(_impl_.target_obsolete_do_not_use_){0},
 8287|     18|  };
 8288|     18|}
_ZN6google8protobuf12FieldOptions10SharedDtorEv:
 8294|     18|inline void FieldOptions::SharedDtor() {
 8295|     18|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|     18|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     18|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     18|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     18|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     18|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     18|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8296|     18|  _impl_._extensions_.~ExtensionSet();
 8297|     18|  _internal_mutable_targets()->~RepeatedField();
 8298|     18|  _impl_.uninterpreted_option_.~RepeatedPtrField();
 8299|     18|}

_ZN6google8protobuf25EncodedDescriptorDatabase3AddEPKvi:
  568|     12|                                    int size) {
  569|     12|  FileDescriptorProto file;
  570|     12|  if (file.ParseFromArray(encoded_file_descriptor, size)) {
  ------------------
  |  Branch (570:7): [True: 12, False: 0]
  ------------------
  571|     12|    return index_->AddFile(file, std::make_pair(encoded_file_descriptor, size));
  572|     12|  } else {
  573|      0|    ABSL_LOG(ERROR) << "Invalid file descriptor data passed to "
  ------------------
  |  |   38|      0|#define ABSL_LOG(severity) ABSL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   24|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |   25|      0|      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
  |  |  ------------------
  ------------------
  574|      0|                       "EncodedDescriptorDatabase::Add().";
  575|      0|    return false;
  576|      0|  }
  577|     12|}
_ZN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9AddSymbolEN4absl12lts_2023012511string_viewE:
  707|     84|    absl::string_view symbol) {
  708|     84|  SymbolEntry entry = {static_cast<int>(all_values_.size() - 1),
  709|     84|                       EncodeString(symbol)};
  710|     84|  std::string entry_as_string = entry.AsString(*this);
  711|       |
  712|       |  // We need to make sure not to violate our map invariant.
  713|       |
  714|       |  // If the symbol name is invalid it could break our lookup algorithm (which
  715|       |  // relies on the fact that '.' sorts before all other characters that are
  716|       |  // valid in symbol names).
  717|     84|  if (!ValidateSymbolName(symbol)) {
  ------------------
  |  Branch (717:7): [True: 0, False: 84]
  ------------------
  718|      0|    ABSL_LOG(ERROR) << "Invalid symbol name: " << entry_as_string;
  ------------------
  |  |   38|      0|#define ABSL_LOG(severity) ABSL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   24|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |   25|      0|      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
  |  |  ------------------
  ------------------
  719|      0|    return false;
  720|      0|  }
  721|       |
  722|     84|  auto iter = FindLastLessOrEqual(&by_symbol_, entry);
  723|     84|  if (!CheckForMutualSubsymbols(entry_as_string, &iter, by_symbol_.end(),
  ------------------
  |  Branch (723:7): [True: 0, False: 84]
  ------------------
  724|     84|                                *this)) {
  725|      0|    return false;
  726|      0|  }
  727|       |
  728|       |  // Same, but on by_symbol_flat_
  729|     84|  auto flat_iter =
  730|     84|      FindLastLessOrEqual(&by_symbol_flat_, entry, by_symbol_.key_comp());
  731|     84|  if (!CheckForMutualSubsymbols(entry_as_string, &flat_iter,
  ------------------
  |  Branch (731:7): [True: 0, False: 84]
  ------------------
  732|     84|                                by_symbol_flat_.end(), *this)) {
  733|      0|    return false;
  734|      0|  }
  735|       |
  736|       |  // OK, no conflicts.
  737|       |
  738|       |  // Insert the new symbol using the iterator as a hint, the new entry will
  739|       |  // appear immediately before the one the iterator is pointing at.
  740|     84|  by_symbol_.insert(iter, entry);
  741|       |
  742|     84|  return true;
  743|     84|}
_ZN6google8protobuf25EncodedDescriptorDatabaseC2Ev:
  895|      2|    : index_(new DescriptorIndex()) {}
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex12EncodeStringEN4absl12lts_2023012511string_viewE:
  443|    108|  String EncodeString(absl::string_view str) const { return String(str); }
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntry8AsStringERKS2_:
  493|    246|    std::string AsString(const DescriptorIndex& index) const {
  494|    246|      auto p = package(index);
  495|    246|      return absl::StrCat(p, p.empty() ? "" : ".", symbol(index));
  ------------------
  |  Branch (495:30): [True: 0, False: 246]
  ------------------
  496|    246|    }
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntry7packageERKS2_:
  485|  1.29k|    absl::string_view package(const DescriptorIndex& index) const {
  486|  1.29k|      return index.DecodeString(index.all_values_[data_offset].encoded_package,
  487|  1.29k|                                data_offset);
  488|  1.29k|    }
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex12DecodeStringERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEi:
  444|  2.64k|  absl::string_view DecodeString(const String& str, int) const { return str; }
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntry6symbolERKS2_:
  489|  1.29k|    absl::string_view symbol(const DescriptorIndex& index) const {
  490|  1.29k|      return index.DecodeString(encoded_symbol, data_offset);
  491|  1.29k|    }
descriptor_database.cc:_ZN6google8protobuf12_GLOBAL__N_118ValidateSymbolNameEN4absl12lts_2023012511string_viewE:
  161|     96|bool ValidateSymbolName(absl::string_view name) {
  162|  1.22k|  for (char c : name) {
  ------------------
  |  Branch (162:15): [True: 1.22k, False: 96]
  ------------------
  163|       |    // I don't trust ctype.h due to locales.  :(
  164|  1.22k|    if (c != '.' && c != '_' && (c < '0' || c > '9') && (c < 'A' || c > 'Z') &&
  ------------------
  |  Branch (164:9): [True: 1.21k, False: 12]
  |  Branch (164:21): [True: 1.21k, False: 0]
  |  Branch (164:34): [True: 0, False: 1.21k]
  |  Branch (164:45): [True: 1.19k, False: 16]
  |  Branch (164:58): [True: 0, False: 1.19k]
  |  Branch (164:69): [True: 1.01k, False: 182]
  ------------------
  165|  1.22k|        (c < 'a' || c > 'z')) {
  ------------------
  |  Branch (165:10): [True: 0, False: 1.01k]
  |  Branch (165:21): [True: 0, False: 1.01k]
  ------------------
  166|      0|      return false;
  167|      0|    }
  168|  1.22k|  }
  169|     96|  return true;
  170|     96|}
descriptor_database.cc:_ZN6google8protobuf12_GLOBAL__N_111IsSubSymbolEN4absl12lts_2023012511string_viewES4_:
  195|    162|bool IsSubSymbol(absl::string_view sub_symbol, absl::string_view super_symbol) {
  196|    162|  return sub_symbol == super_symbol ||
  ------------------
  |  Branch (196:10): [True: 0, False: 162]
  ------------------
  197|    162|         (absl::StartsWith(super_symbol, sub_symbol) &&
  ------------------
  |  Branch (197:11): [True: 8, False: 154]
  ------------------
  198|    162|          super_symbol[sub_symbol.size()] == '.');
  ------------------
  |  Branch (198:11): [True: 0, False: 8]
  ------------------
  199|    162|}
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntry4nameERKS2_:
  461|     52|    absl::string_view name(const DescriptorIndex& index) const {
  462|     52|      return index.DecodeString(encoded_name, data_offset);
  463|     52|    }
_ZN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex7AddFileINS0_19FileDescriptorProtoEEEbRKT_NSt3__14pairIPKviEE:
  639|     12|                                                         Value value) {
  640|       |  // We push `value` into the array first. This is important because the AddXXX
  641|       |  // functions below will expect it to be there.
  642|     12|  all_values_.push_back({value.first, value.second, {}});
  643|       |
  644|     12|  if (!ValidateSymbolName(file.package())) {
  ------------------
  |  Branch (644:7): [True: 0, False: 12]
  ------------------
  645|      0|    ABSL_LOG(ERROR) << "Invalid package name: " << file.package();
  ------------------
  |  |   38|      0|#define ABSL_LOG(severity) ABSL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   24|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |   25|      0|      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
  |  |  ------------------
  ------------------
  646|      0|    return false;
  647|      0|  }
  648|     12|  all_values_.back().encoded_package = EncodeString(file.package());
  649|       |
  650|     12|  if (!by_name_
  ------------------
  |  Branch (650:7): [True: 0, False: 12]
  |  Branch (650:7): [True: 0, False: 12]
  ------------------
  651|     12|           .insert({static_cast<int>(all_values_.size() - 1),
  652|     12|                    EncodeString(file.name())})
  653|     12|           .second ||
  654|     12|      std::binary_search(by_name_flat_.begin(), by_name_flat_.end(),
  ------------------
  |  Branch (654:7): [True: 0, False: 12]
  ------------------
  655|     12|                         file.name(), by_name_.key_comp())) {
  656|      0|    ABSL_LOG(ERROR) << "File already exists in database: " << file.name();
  ------------------
  |  |   38|      0|#define ABSL_LOG(severity) ABSL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   24|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |   25|      0|      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
  |  |  ------------------
  ------------------
  657|      0|    return false;
  658|      0|  }
  659|       |
  660|     80|  for (const auto& message_type : file.message_type()) {
  ------------------
  |  Branch (660:33): [True: 80, False: 12]
  ------------------
  661|     80|    if (!AddSymbol(message_type.name())) return false;
  ------------------
  |  Branch (661:9): [True: 0, False: 80]
  ------------------
  662|     80|    if (!AddNestedExtensions(file.name(), message_type)) return false;
  ------------------
  |  Branch (662:9): [True: 0, False: 80]
  ------------------
  663|     80|  }
  664|     12|  for (const auto& enum_type : file.enum_type()) {
  ------------------
  |  Branch (664:30): [True: 4, False: 12]
  ------------------
  665|      4|    if (!AddSymbol(enum_type.name())) return false;
  ------------------
  |  Branch (665:9): [True: 0, False: 4]
  ------------------
  666|      4|  }
  667|     12|  for (const auto& extension : file.extension()) {
  ------------------
  |  Branch (667:30): [True: 0, False: 12]
  ------------------
  668|      0|    if (!AddSymbol(extension.name())) return false;
  ------------------
  |  Branch (668:9): [True: 0, False: 0]
  ------------------
  669|      0|    if (!AddExtension(file.name(), extension)) return false;
  ------------------
  |  Branch (669:9): [True: 0, False: 0]
  ------------------
  670|      0|  }
  671|     12|  for (const auto& service : file.service()) {
  ------------------
  |  Branch (671:28): [True: 0, False: 12]
  ------------------
  672|      0|    if (!AddSymbol(service.name())) return false;
  ------------------
  |  Branch (672:9): [True: 0, False: 0]
  ------------------
  673|      0|  }
  674|       |
  675|     12|  return true;
  676|     12|}
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareclERKNS2_9FileEntryES6_:
  468|     26|    bool operator()(const FileEntry& a, const FileEntry& b) const {
  469|     26|      return a.name(index) < b.name(index);
  470|     26|    }
_ZN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex19AddNestedExtensionsINS0_15DescriptorProtoEEEbN4absl12lts_2023012511string_viewERKT_:
  747|     96|    absl::string_view filename, const DescProto& message_type) {
  748|     96|  for (const auto& nested_type : message_type.nested_type()) {
  ------------------
  |  Branch (748:32): [True: 16, False: 96]
  ------------------
  749|     16|    if (!AddNestedExtensions(filename, nested_type)) return false;
  ------------------
  |  Branch (749:9): [True: 0, False: 16]
  ------------------
  750|     16|  }
  751|     96|  for (const auto& extension : message_type.extension()) {
  ------------------
  |  Branch (751:30): [True: 0, False: 96]
  ------------------
  752|      0|    if (!AddExtension(filename, extension)) return false;
  ------------------
  |  Branch (752:9): [True: 0, False: 0]
  ------------------
  753|      0|  }
  754|     96|  return true;
  755|     96|}
descriptor_database.cc:_ZN6google8protobuf12_GLOBAL__N_119FindLastLessOrEqualIN4absl12lts_202301259btree_setINS0_25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS7_13SymbolCompareENSt3__19allocatorIS8_EEEES8_EENT_14const_iteratorEPKSE_RKT0_:
  177|     84|    const Container* container, const Key& key) {
  178|     84|  auto iter = container->upper_bound(key);
  179|     84|  if (iter != container->begin()) --iter;
  ------------------
  |  Branch (179:7): [True: 78, False: 6]
  ------------------
  180|     84|  return iter;
  181|     84|}
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareclINS2_11SymbolEntryES5_EEbRKT_RKT0_:
  519|    526|    bool operator()(const T& lhs, const U& rhs) const {
  520|    526|      auto lhs_parts = GetParts(lhs);
  521|    526|      auto rhs_parts = GetParts(rhs);
  522|       |
  523|       |      // Fast path to avoid making the whole string for common cases.
  524|    526|      if (int res =
  ------------------
  |  Branch (524:15): [True: 0, False: 526]
  ------------------
  525|    526|              lhs_parts.first.substr(0, rhs_parts.first.size())
  526|    526|                  .compare(rhs_parts.first.substr(0, lhs_parts.first.size()))) {
  527|       |        // If the packages already differ, exit early.
  528|      0|        return res < 0;
  529|    526|      } else if (lhs_parts.first.size() == rhs_parts.first.size()) {
  ------------------
  |  Branch (529:18): [True: 526, False: 0]
  ------------------
  530|    526|        return lhs_parts.second < rhs_parts.second;
  531|    526|      }
  532|      0|      return AsString(lhs) < AsString(rhs);
  533|    526|    }
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompare8GetPartsERKNS2_11SymbolEntryE:
  508|  1.05k|        const SymbolEntry& entry) const {
  509|  1.05k|      auto package = entry.package(index);
  510|  1.05k|      if (package.empty()) return {entry.symbol(index), absl::string_view{}};
  ------------------
  |  Branch (510:11): [True: 0, False: 1.05k]
  ------------------
  511|  1.05k|      return {package, entry.symbol(index)};
  512|  1.05k|    }
descriptor_database.cc:_ZN6google8protobufL24CheckForMutualSubsymbolsIN4absl12lts_2023012518container_internal14btree_iteratorIKNS4_10btree_nodeINS4_10set_paramsINS0_25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS9_13SymbolCompareENSt3__19allocatorISA_EELi256ELb0EEEEERKSA_PSI_EENS5_ISG_RSA_PSA_EES9_EEbNS3_11string_viewEPT_T0_RKT1_:
  680|     84|                                     Iter2 end, const Index& index) {
  681|     84|  if (*iter != end) {
  ------------------
  |  Branch (681:7): [True: 82, False: 2]
  ------------------
  682|     82|    if (IsSubSymbol((*iter)->AsString(index), symbol_name)) {
  ------------------
  |  Branch (682:9): [True: 0, False: 82]
  ------------------
  683|      0|      ABSL_LOG(ERROR) << "Symbol name \"" << symbol_name
  ------------------
  |  |   38|      0|#define ABSL_LOG(severity) ABSL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   24|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |   25|      0|      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
  |  |  ------------------
  ------------------
  684|      0|                      << "\" conflicts with the existing symbol \""
  685|      0|                      << (*iter)->AsString(index) << "\".";
  686|      0|      return false;
  687|      0|    }
  688|       |
  689|       |    // OK, that worked.  Now we have to make sure that no symbol in the map is
  690|       |    // a sub-symbol of the one we are inserting.  The only symbol which could
  691|       |    // be so is the first symbol that is greater than the new symbol.  Since
  692|       |    // |iter| points at the last symbol that is less than or equal, we just have
  693|       |    // to increment it.
  694|     82|    ++*iter;
  695|       |
  696|     82|    if (*iter != end && IsSubSymbol(symbol_name, (*iter)->AsString(index))) {
  ------------------
  |  Branch (696:9): [True: 80, False: 2]
  |  Branch (696:9): [True: 0, False: 82]
  |  Branch (696:25): [True: 0, False: 80]
  ------------------
  697|      0|      ABSL_LOG(ERROR) << "Symbol name \"" << symbol_name
  ------------------
  |  |   38|      0|#define ABSL_LOG(severity) ABSL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   24|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |   25|      0|      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
  |  |  ------------------
  ------------------
  698|      0|                      << "\" conflicts with the existing symbol \""
  699|      0|                      << (*iter)->AsString(index) << "\".";
  700|      0|      return false;
  701|      0|    }
  702|     82|  }
  703|     84|  return true;
  704|     84|}
descriptor_database.cc:_ZN6google8protobuf12_GLOBAL__N_119FindLastLessOrEqualINSt3__16vectorINS0_25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS3_9allocatorIS7_EEEES7_NS6_13SymbolCompareEEENT_14const_iteratorEPKSC_RKT0_RKT1_:
  186|     84|    const Container* container, const Key& key, const Cmp& cmp) {
  187|     84|  auto iter = std::upper_bound(container->begin(), container->end(), key, cmp);
  188|     84|  if (iter != container->begin()) --iter;
  ------------------
  |  Branch (188:7): [True: 0, False: 84]
  ------------------
  189|     84|  return iter;
  190|     84|}
descriptor_database.cc:_ZN6google8protobufL24CheckForMutualSubsymbolsINSt3__111__wrap_iterIPKNS0_25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEENS3_IPS6_EES5_EEbN4absl12lts_2023012511string_viewEPT_T0_RKT1_:
  680|     84|                                     Iter2 end, const Index& index) {
  681|     84|  if (*iter != end) {
  ------------------
  |  Branch (681:7): [True: 0, False: 84]
  ------------------
  682|      0|    if (IsSubSymbol((*iter)->AsString(index), symbol_name)) {
  ------------------
  |  Branch (682:9): [True: 0, False: 0]
  ------------------
  683|      0|      ABSL_LOG(ERROR) << "Symbol name \"" << symbol_name
  ------------------
  |  |   38|      0|#define ABSL_LOG(severity) ABSL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   24|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |   25|      0|      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
  |  |  ------------------
  ------------------
  684|      0|                      << "\" conflicts with the existing symbol \""
  685|      0|                      << (*iter)->AsString(index) << "\".";
  686|      0|      return false;
  687|      0|    }
  688|       |
  689|       |    // OK, that worked.  Now we have to make sure that no symbol in the map is
  690|       |    // a sub-symbol of the one we are inserting.  The only symbol which could
  691|       |    // be so is the first symbol that is greater than the new symbol.  Since
  692|       |    // |iter| points at the last symbol that is less than or equal, we just have
  693|       |    // to increment it.
  694|      0|    ++*iter;
  695|       |
  696|      0|    if (*iter != end && IsSubSymbol(symbol_name, (*iter)->AsString(index))) {
  ------------------
  |  Branch (696:9): [True: 0, False: 0]
  |  Branch (696:9): [True: 0, False: 0]
  |  Branch (696:25): [True: 0, False: 0]
  ------------------
  697|      0|      ABSL_LOG(ERROR) << "Symbol name \"" << symbol_name
  ------------------
  |  |   38|      0|#define ABSL_LOG(severity) ABSL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   24|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |   25|      0|      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
  |  |  ------------------
  ------------------
  698|      0|                      << "\" conflicts with the existing symbol \""
  699|      0|                      << (*iter)->AsString(index) << "\".";
  700|      0|      return false;
  701|      0|    }
  702|      0|  }
  703|     84|  return true;
  704|     84|}

_ZN6google8protobuf8internal12ExtensionSetC2EPNS0_5ArenaE:
  189|     32|               : Arena::CreateArray<KeyValue>(arena_, flat_capacity_)} {}
_ZN6google8protobuf8internal12ExtensionSetD2Ev:
  191|     32|ExtensionSet::~ExtensionSet() {
  192|       |  // Deletes all allocated extensions.
  193|     32|  if (arena_ == nullptr) {
  ------------------
  |  Branch (193:7): [True: 32, False: 0]
  ------------------
  194|     32|    ForEach([](int /* number */, Extension& ext) { ext.Free(); });
  195|     32|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  551|     32|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 32]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 32]
  |  |  ------------------
  ------------------
  196|      0|      delete map_.large;
  197|     32|    } else {
  198|     32|      DeleteFlatMap(map_.flat, flat_capacity_);
  199|     32|    }
  200|     32|  }
  201|     32|}
_ZN6google8protobuf8internal12ExtensionSet13DeleteFlatMapEPKNS2_8KeyValueEt:
  204|     32|                                 uint16_t flat_capacity) {
  205|       |  // Arena::CreateArray already requires a trivially destructible type, but
  206|       |  // ensure this constraint is not violated in the future.
  207|     32|  static_assert(std::is_trivially_destructible<KeyValue>::value,
  208|     32|                "CreateArray requires a trivially destructible type");
  209|       |  // A const-cast is needed, but this is safe as we are about to deallocate the
  210|       |  // array.
  211|     32|  internal::SizedArrayDelete(const_cast<KeyValue*>(flat),
  212|     32|                             sizeof(*flat) * flat_capacity);
  213|     32|}
_ZNK6google8protobuf8internal12ExtensionSet13IsInitializedEPKNS0_11MessageLiteE:
 1217|     32|bool ExtensionSet::IsInitialized(const MessageLite* extendee) const {
 1218|       |  // Extensions are never required.  However, we need to check that all
 1219|       |  // embedded messages are initialized.
 1220|     32|  if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  551|     32|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 32]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 32]
  |  |  ------------------
  ------------------
 1221|      0|    for (const auto& kv : *map_.large) {
  ------------------
  |  Branch (1221:25): [True: 0, False: 0]
  ------------------
 1222|      0|      if (!kv.second.IsInitialized(this, extendee, kv.first, arena_)) {
  ------------------
  |  Branch (1222:11): [True: 0, False: 0]
  ------------------
 1223|      0|        return false;
 1224|      0|      }
 1225|      0|    }
 1226|      0|    return true;
 1227|      0|  }
 1228|     32|  for (const KeyValue* it = flat_begin(); it != flat_end(); ++it) {
  ------------------
  |  Branch (1228:43): [True: 0, False: 32]
  ------------------
 1229|      0|    if (!it->second.IsInitialized(this, extendee, it->first, arena_)) {
  ------------------
  |  Branch (1229:9): [True: 0, False: 0]
  ------------------
 1230|      0|      return false;
 1231|      0|    }
 1232|      0|  }
 1233|     32|  return true;
 1234|     32|}

_ZN6google8protobuf8internal40InitializeFileDescriptorDefaultInstancesEv:
  107|     12|void InitializeFileDescriptorDefaultInstances() {
  108|       |#if !defined(PROTOBUF_CONSTINIT_DEFAULT_INSTANCES)
  109|       |  static std::true_type init =
  110|       |      (InitializeFileDescriptorDefaultInstancesSlow(), std::true_type{});
  111|       |  (void)init;
  112|       |#endif  // !defined(PROTOBUF_CONSTINIT_DEFAULT_INSTANCES)
  113|     12|}
_ZN6google8protobuf8internal20AddDescriptorsRunnerC2EPKNS1_15DescriptorTableE:
 3675|     12|AddDescriptorsRunner::AddDescriptorsRunner(const DescriptorTable* table) {
 3676|     12|  AddDescriptors(table);
 3677|     12|}
generated_message_reflection.cc:_ZN6google8protobuf12_GLOBAL__N_114AddDescriptorsEPKNS0_8internal15DescriptorTableE:
 3635|     16|void AddDescriptors(const DescriptorTable* table) {
 3636|       |  // AddDescriptors is not thread safe. Callers need to ensure calls are
 3637|       |  // properly serialized. This function is only called pre-main by global
 3638|       |  // descriptors and we can assume single threaded access or it's called
 3639|       |  // by AssignDescriptorImpl which uses a mutex to sequence calls.
 3640|     16|  if (table->is_initialized) return;
  ------------------
  |  Branch (3640:7): [True: 4, False: 12]
  ------------------
 3641|     12|  table->is_initialized = true;
 3642|     12|  AddDescriptorsImpl(table);
 3643|     12|}
generated_message_reflection.cc:_ZN6google8protobuf12_GLOBAL__N_118AddDescriptorsImplEPKNS0_8internal15DescriptorTableE:
 3617|     12|void AddDescriptorsImpl(const DescriptorTable* table) {
 3618|       |  // Reflection refers to the default fields so make sure they are initialized.
 3619|     12|  internal::InitProtobufDefaults();
 3620|     12|  internal::InitializeFileDescriptorDefaultInstances();
 3621|       |
 3622|       |  // Ensure all dependent descriptors are registered to the generated descriptor
 3623|       |  // pool and message factory.
 3624|     12|  int num_deps = table->num_deps;
 3625|     16|  for (int i = 0; i < num_deps; i++) {
  ------------------
  |  Branch (3625:19): [True: 4, False: 12]
  ------------------
 3626|       |    // In case of weak fields deps[i] could be null.
 3627|      4|    if (table->deps[i]) AddDescriptors(table->deps[i]);
  ------------------
  |  Branch (3627:9): [True: 4, False: 0]
  ------------------
 3628|      4|  }
 3629|       |
 3630|       |  // Register the descriptor of this file.
 3631|     12|  DescriptorPool::InternalAddGeneratedFile(table->descriptor, table->size);
 3632|     12|  MessageFactory::InternalRegisterGeneratedFile(table);
 3633|     12|}

_ZN6google8protobuf8internal8TcParser9ParseLoopEPNS0_11MessageLiteEPKcPNS1_12ParseContextEPKNS1_16TcParseTableBaseE:
   90|    746|    const TcParseTableBase* table) {
   91|       |  // Note: TagDispatch uses a dispatch table at "&table->fast_entries".
   92|       |  // For fast dispatch, we'd like to have a pointer to that, but if we use
   93|       |  // that expression, there's no easy way to get back to "table", which we also
   94|       |  // need during dispatch.  It turns out that "table + 1" points exactly to
   95|       |  // fast_entries, so we just increment table by 1 here, to get the register
   96|       |  // holding the value we want.
   97|    746|  table += 1;
   98|  2.26k|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (98:10): [True: 1.51k, False: 746]
  ------------------
   99|  1.51k|#if defined(__GNUC__)
  100|       |    // Note: this asm prevents the compiler (clang, specifically) from
  101|       |    // believing (thanks to CSE) that it needs to dedicate a registeer both
  102|       |    // to "table" and "&table->fast_entries".
  103|       |    // TODO(b/64614992): remove this asm
  104|  1.51k|    asm("" : "+r"(table));
  105|  1.51k|#endif
  106|  1.51k|    ptr = TagDispatch(msg, ptr, ctx, TcFieldData::DefaultInit(), table - 1, 0);
  107|  1.51k|    if (ptr == nullptr) break;
  ------------------
  |  Branch (107:9): [True: 0, False: 1.51k]
  ------------------
  108|  1.51k|    if (ctx->LastTag() != 1) break;  // Ended on terminating tag
  ------------------
  |  Branch (108:9): [True: 0, False: 1.51k]
  ------------------
  109|  1.51k|  }
  110|    746|  return ptr;
  111|    746|}
_ZN6google8protobuf8internal8TcParser14FindFieldEntryEPKNS1_16TcParseTableBaseEj:
  165|     14|    const TcParseTableBase* table, uint32_t field_num) {
  166|     14|  const FieldEntry* const field_entries = table->field_entries_begin();
  167|       |
  168|     14|  uint32_t fstart = 1;
  169|     14|  uint32_t adj_fnum = field_num - fstart;
  170|       |
  171|     14|  if (PROTOBUF_PREDICT_TRUE(adj_fnum < 32)) {
  ------------------
  |  |  550|     14|# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (550:35): [True: 2, False: 12]
  |  |  |  Branch (550:53): [Folded - Ignored]
  |  |  |  Branch (550:62): [True: 2, False: 12]
  |  |  ------------------
  ------------------
  172|      2|    uint32_t skipmap = table->skipmap32;
  173|      2|    uint32_t skipbit = 1 << adj_fnum;
  174|      2|    if (PROTOBUF_PREDICT_FALSE(skipmap & skipbit)) return nullptr;
  ------------------
  |  |  551|      2|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 2]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  175|      2|    skipmap &= skipbit - 1;
  176|       |#if (__GNUC__ || __clang__) && __POPCNT__
  177|       |    // Note: here and below, skipmap typically has very few set bits
  178|       |    // (31 in the worst case, but usually zero) so a loop isn't that
  179|       |    // bad, and a compiler-generated popcount is typically only
  180|       |    // worthwhile if the processor itself has hardware popcount support.
  181|       |    adj_fnum -= __builtin_popcount(skipmap);
  182|       |#else
  183|     18|    while (skipmap) {
  ------------------
  |  Branch (183:12): [True: 16, False: 2]
  ------------------
  184|     16|      --adj_fnum;
  185|     16|      skipmap &= skipmap - 1;
  186|     16|    }
  187|      2|#endif
  188|      2|    auto* entry = field_entries + adj_fnum;
  189|      2|    PROTOBUF_ASSUME(entry != nullptr);
  ------------------
  |  | 1101|      2|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  190|      2|    return entry;
  191|      2|  }
  192|     12|  const uint16_t* lookup_table = table->field_lookup_begin();
  193|     12|  for (;;) {
  194|     12|#ifdef PROTOBUF_LITTLE_ENDIAN
  195|     12|    memcpy(&fstart, lookup_table, sizeof(fstart));
  196|       |#else
  197|       |    fstart = lookup_table[0] | (lookup_table[1] << 16);
  198|       |#endif
  199|     12|    lookup_table += sizeof(fstart) / sizeof(*lookup_table);
  200|     12|    uint32_t num_skip_entries = *lookup_table++;
  201|     12|    if (field_num < fstart) return nullptr;
  ------------------
  |  Branch (201:9): [True: 0, False: 12]
  ------------------
  202|     12|    adj_fnum = field_num - fstart;
  203|     12|    uint32_t skip_num = adj_fnum / 16;
  204|     12|    if (PROTOBUF_PREDICT_TRUE(skip_num < num_skip_entries)) {
  ------------------
  |  |  550|     12|# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (550:35): [True: 12, False: 0]
  |  |  |  Branch (550:53): [Folded - Ignored]
  |  |  |  Branch (550:62): [True: 12, False: 0]
  |  |  ------------------
  ------------------
  205|       |      // for each group of 16 fields we have:
  206|       |      // a bitmap of 16 bits
  207|       |      // a 16-bit field-entry offset for the first of them.
  208|     12|      auto* skip_data = lookup_table + (adj_fnum / 16) * (sizeof(SkipEntry16) /
  209|     12|                                                          sizeof(uint16_t));
  210|     12|      SkipEntry16 se = {skip_data[0], skip_data[1]};
  211|     12|      adj_fnum &= 15;
  212|     12|      uint32_t skipmap = se.skipmap;
  213|     12|      uint16_t skipbit = 1 << adj_fnum;
  214|     12|      if (PROTOBUF_PREDICT_FALSE(skipmap & skipbit)) return nullptr;
  ------------------
  |  |  551|     12|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 12]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 12]
  |  |  ------------------
  ------------------
  215|     12|      skipmap &= skipbit - 1;
  216|     12|      adj_fnum += se.field_entry_offset;
  217|       |#if (__GNUC__ || __clang__) && __POPCNT__
  218|       |      adj_fnum -= __builtin_popcount(skipmap);
  219|       |#else
  220|     12|      while (skipmap) {
  ------------------
  |  Branch (220:14): [True: 0, False: 12]
  ------------------
  221|      0|        --adj_fnum;
  222|      0|        skipmap &= skipmap - 1;
  223|      0|      }
  224|     12|#endif
  225|     12|      auto* entry = field_entries + adj_fnum;
  226|     12|      PROTOBUF_ASSUME(entry != nullptr);
  ------------------
  |  | 1101|     12|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  227|     12|      return entry;
  228|     12|    }
  229|      0|    lookup_table +=
  230|      0|        num_skip_entries * (sizeof(SkipEntry16) / sizeof(*lookup_table));
  231|      0|  }
  232|     12|}
_ZN6google8protobuf8internal8TcParser9MiniParseEPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  367|     14|    PROTOBUF_TC_PARAM_NO_DATA_DECL) {
  368|     14|  PROTOBUF_MUSTTAIL return MiniParse<false>(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|     14|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return MiniParse<false>(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|     14|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  369|     14|}
_ZN6google8protobuf8internal8TcParser8FastMtS1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  470|     32|PROTOBUF_NOINLINE const char* TcParser::FastMtS1(PROTOBUF_TC_PARAM_DECL) {
  471|     32|  PROTOBUF_MUSTTAIL return SingularParseMessageAuxImpl<uint8_t, false, true>(
  ------------------
  |  |  347|     32|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
  472|     32|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|     32|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  473|     32|}
_ZN6google8protobuf8internal8TcParser8FastMtR1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  562|    196|PROTOBUF_NOINLINE const char* TcParser::FastMtR1(PROTOBUF_TC_PARAM_DECL) {
  563|    196|  PROTOBUF_MUSTTAIL return RepeatedParseMessageAuxImpl<uint8_t, false, true>(
  ------------------
  |  |  347|    196|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
  564|    196|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|    196|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  565|    196|}
_ZN6google8protobuf8internal8TcParser8FastV8S1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  889|     28|PROTOBUF_NOINLINE const char* TcParser::FastV8S1(PROTOBUF_TC_PARAM_DECL) {
  890|     28|  using TagType = uint8_t;
  891|       |
  892|       |  // Special case for a varint bool field with a tag of 1 byte:
  893|       |  // The coded_tag() field will actually contain the value too and we can check
  894|       |  // both at the same time.
  895|     28|  auto coded_tag = data.coded_tag<uint16_t>();
  896|     28|  if (PROTOBUF_PREDICT_TRUE(coded_tag == 0x0000 || coded_tag == 0x0100)) {
  ------------------
  |  |  550|     56|# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (550:35): [True: 28, False: 0]
  |  |  |  Branch (550:53): [Folded - Ignored]
  |  |  |  Branch (550:63): [True: 0, False: 28]
  |  |  |  Branch (550:63): [True: 28, False: 0]
  |  |  ------------------
  ------------------
  897|     28|    auto& field = RefAt<bool>(msg, data.offset());
  898|       |    // Note: we use `data.data` because Clang generates suboptimal code when
  899|       |    // using coded_tag.
  900|       |    // In x86_64 this uses the CH register to read the second byte out of
  901|       |    // `data`.
  902|     28|    uint8_t value = data.data >> 8;
  903|       |    // The assume allows using a mov instead of test+setne.
  904|     28|    PROTOBUF_ASSUME(value <= 1);
  ------------------
  |  | 1101|     28|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
  905|     28|    field = static_cast<bool>(value);
  906|       |
  907|     28|    ptr += sizeof(TagType) + 1;  // Consume the tag and the value.
  908|     28|    hasbits |= (uint64_t{1} << data.hasbit_idx());
  909|       |
  910|     28|    PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|     28|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|     28|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  911|     28|  }
  912|       |
  913|       |  // If it didn't match above either the tag is wrong, or the value is encoded
  914|       |  // non-canonically.
  915|       |  // Jump to MiniParse as wrong tag is the most probable reason.
  916|     28|  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  917|     28|}
_ZN6google8protobuf8internal8TcParser8FastV8S2EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  919|     20|PROTOBUF_NOINLINE const char* TcParser::FastV8S2(PROTOBUF_TC_PARAM_DECL) {
  920|     20|  PROTOBUF_MUSTTAIL return SingularVarint<bool, uint16_t>(
  ------------------
  |  |  347|     20|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
  921|     20|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|     20|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  922|     20|}
_ZN6google8protobuf8internal8TcParser9FastV32S1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  923|    622|PROTOBUF_NOINLINE const char* TcParser::FastV32S1(PROTOBUF_TC_PARAM_DECL) {
  924|    622|  PROTOBUF_MUSTTAIL return FastVarintS1<uint32_t>(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  347|    622|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return FastVarintS1<uint32_t>(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|    622|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  925|    622|}
_ZN6google8protobuf8internal8TcParser9FastEr0S1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1308|      2|PROTOBUF_NOINLINE const char* TcParser::FastEr0S1(PROTOBUF_TC_PARAM_DECL) {
 1309|      2|  PROTOBUF_MUSTTAIL return SingularEnumSmallRange<uint8_t, 0>(
  ------------------
  |  |  347|      2|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
 1310|      2|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|      2|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1311|      2|}
_ZN6google8protobuf8internal8TcParser9FastEr1S1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1318|    774|PROTOBUF_NOINLINE const char* TcParser::FastEr1S1(PROTOBUF_TC_PARAM_DECL) {
 1319|    774|  PROTOBUF_MUSTTAIL return SingularEnumSmallRange<uint8_t, 1>(
  ------------------
  |  |  347|    774|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
 1320|    774|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|    774|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1321|    774|}
_ZN6google8protobuf8internal8TcParser7FastSS1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1526|    930|PROTOBUF_NOINLINE const char* TcParser::FastSS1(PROTOBUF_TC_PARAM_DECL) {
 1527|    930|  PROTOBUF_MUSTTAIL return SingularString<uint8_t, ArenaStringPtr,
  ------------------
  |  |  347|    930|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
 1528|    930|                                          kUtf8ValidateOnly>(
 1529|    930|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|    930|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1530|    930|}
_ZN6google8protobuf8internal8TcParser7FastSS2EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1531|     12|PROTOBUF_NOINLINE const char* TcParser::FastSS2(PROTOBUF_TC_PARAM_DECL) {
 1532|     12|  PROTOBUF_MUSTTAIL return SingularString<uint16_t, ArenaStringPtr,
  ------------------
  |  |  347|     12|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
 1533|     12|                                          kUtf8ValidateOnly>(
 1534|     12|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|     12|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1535|     12|}
_ZN6google8protobuf8internal8TcParser7FastSR1EPNS0_11MessageLiteEPKcPNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1649|      2|PROTOBUF_NOINLINE const char* TcParser::FastSR1(PROTOBUF_TC_PARAM_DECL) {
 1650|      2|  PROTOBUF_MUSTTAIL return RepeatedString<
  ------------------
  |  |  347|      2|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
 1651|      2|      uint8_t, RepeatedPtrField<std::string>, kUtf8ValidateOnly>(
 1652|      2|      PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|      2|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1653|      2|}
_ZN6google8protobuf8internal8TcParser17MaybeGetSplitBaseEPNS0_11MessageLiteEbPKNS1_16TcParseTableBaseE:
 1755|     14|                                  const TcParseTableBase* table) {
 1756|     14|  void* out = msg;
 1757|     14|  if (is_split) {
  ------------------
  |  Branch (1757:7): [True: 0, False: 14]
  ------------------
 1758|      0|    const uint32_t split_offset = GetSplitOffset(table);
 1759|      0|    void* default_split =
 1760|      0|        TcParser::RefAt<void*>(table->default_instance, split_offset);
 1761|      0|    void*& split = TcParser::RefAt<void*>(msg, split_offset);
 1762|      0|    if (split == default_split) {
  ------------------
  |  Branch (1762:9): [True: 0, False: 0]
  ------------------
 1763|       |      // Allocate split instance when needed.
 1764|      0|      uint32_t size = GetSizeofSplit(table);
 1765|      0|      Arena* arena = msg->GetArenaForAllocation();
 1766|      0|      split = (arena == nullptr) ? ::operator new(size)
  ------------------
  |  Branch (1766:15): [True: 0, False: 0]
  ------------------
 1767|      0|                                 : arena->AllocateAligned(size);
 1768|      0|      memcpy(split, default_split, size);
 1769|      0|    }
 1770|      0|    out = split;
 1771|      0|  }
 1772|     14|  return out;
 1773|     14|}
_ZN6google8protobuf8internal8TcParser12MpVerifyUtf8EN4absl12lts_2023012511string_viewEPKNS1_16TcParseTableBaseERKNS6_10FieldEntryEt:
 2099|     12|                            const FieldEntry& entry, uint16_t xform_val) {
 2100|     12|  if (xform_val == field_layout::kTvUtf8) {
  ------------------
  |  Branch (2100:7): [True: 0, False: 12]
  ------------------
 2101|      0|    if (!utf8_range::IsStructurallyValid(wire_bytes)) {
  ------------------
  |  Branch (2101:9): [True: 0, False: 0]
  ------------------
 2102|      0|      PrintUTF8ErrorLog(MessageName(table), FieldName(table, &entry), "parsing",
 2103|      0|                        false);
 2104|      0|      return false;
 2105|      0|    }
 2106|      0|    return true;
 2107|      0|  }
 2108|       |#ifndef NDEBUG
 2109|       |  if (xform_val == field_layout::kTvUtf8Debug) {
 2110|       |    if (!utf8_range::IsStructurallyValid(wire_bytes)) {
 2111|       |      PrintUTF8ErrorLog(MessageName(table), FieldName(table, &entry), "parsing",
 2112|       |                        false);
 2113|       |    }
 2114|       |  }
 2115|       |#endif  // NDEBUG
 2116|     12|  return true;
 2117|     12|}
generated_message_tctable_lite.cc:_ZN6google8protobuf8internal12_GLOBAL__N_114EnumIsValidAuxEitNS1_16TcParseTableBase8FieldAuxE:
  801|      2|                    TcParseTableBase::FieldAux aux) {
  802|      2|  if (xform_val == field_layout::kTvRange) {
  ------------------
  |  Branch (802:7): [True: 2, False: 0]
  ------------------
  803|      2|    auto lo = aux.enum_range.start;
  804|      2|    return lo <= val && val < (lo + aux.enum_range.length);
  ------------------
  |  Branch (804:12): [True: 2, False: 0]
  |  Branch (804:25): [True: 2, False: 0]
  ------------------
  805|      2|  }
  806|      0|  return aux.enum_validator(val);
  807|      2|}
_ZN6google8protobuf8internal8TcParser9MiniParseILb0EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  283|     14|    PROTOBUF_TC_PARAM_DECL) {
  284|     14|  TestMiniParseResult* test_out;
  285|     14|  if (export_called_function) {
  ------------------
  |  Branch (285:7): [Folded - Ignored]
  ------------------
  286|      0|    test_out = reinterpret_cast<TestMiniParseResult*>(
  287|      0|        static_cast<uintptr_t>(data.data));
  288|      0|  }
  289|       |
  290|     14|  uint32_t tag;
  291|     14|  ptr = ReadTagInlined(ptr, &tag);
  292|     14|  if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) {
  ------------------
  |  |  551|     14|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 14]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 14]
  |  |  ------------------
  ------------------
  293|      0|    if (export_called_function) *test_out = {Error};
  ------------------
  |  Branch (293:9): [Folded - Ignored]
  ------------------
  294|      0|    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  295|      0|  }
  296|       |
  297|     14|  auto* entry = FindFieldEntry(table, tag >> 3);
  298|     14|  if (entry == nullptr) {
  ------------------
  |  Branch (298:7): [True: 0, False: 14]
  ------------------
  299|      0|    if (export_called_function) *test_out = {table->fallback, tag};
  ------------------
  |  Branch (299:9): [Folded - Ignored]
  ------------------
  300|      0|    data.data = tag;
  301|      0|    PROTOBUF_MUSTTAIL return table->fallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return table->fallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  302|      0|  }
  303|       |
  304|       |  // The handler may need the tag and the entry to resolve fallback logic. Both
  305|       |  // of these are 32 bits, so pack them into (the 64-bit) `data`. Since we can't
  306|       |  // pack the entry pointer itself, just pack its offset from `table`.
  307|     14|  uint64_t entry_offset = reinterpret_cast<const char*>(entry) -
  308|     14|                          reinterpret_cast<const char*>(table);
  309|     14|  data.data = entry_offset << 32 | tag;
  310|       |
  311|     14|  using field_layout::FieldKind;
  312|     14|  auto field_type =
  313|     14|      entry->type_card & (+field_layout::kSplitMask | FieldKind::kFkMask);
  314|       |
  315|     14|  static constexpr TailCallParseFunc kMiniParseTable[] = {
  316|     14|      &MpFallback,        // FieldKind::kFkNone
  317|     14|      &MpVarint<false>,   // FieldKind::kFkVarint
  318|     14|      &MpPackedVarint,    // FieldKind::kFkPackedVarint
  319|     14|      &MpFixed<false>,    // FieldKind::kFkFixed
  320|     14|      &MpPackedFixed,     // FieldKind::kFkPackedFixed
  321|     14|      &MpString<false>,   // FieldKind::kFkString
  322|     14|      &MpMessage<false>,  // FieldKind::kFkMessage
  323|     14|      &MpMap,             // FieldKind::kFkMap
  324|     14|      &Error,             // kSplitMask | FieldKind::kFkNone
  325|     14|      &MpVarint<true>,    // kSplitMask | FieldKind::kFkVarint
  326|     14|      &Error,             // kSplitMask | FieldKind::kFkPackedVarint
  327|     14|      &MpFixed<true>,     // kSplitMask | FieldKind::kFkFixed
  328|     14|      &Error,             // kSplitMask | FieldKind::kFkPackedFixed
  329|     14|      &MpString<true>,    // kSplitMask | FieldKind::kFkString
  330|     14|      &MpMessage<true>,   // kSplitMask | FieldKind::kFkMessage
  331|     14|      &Error,             // kSplitMask | FieldKind::kFkMap
  332|     14|  };
  333|       |  // Just to be sure we got the order right, above.
  334|     14|  static_assert(0 == FieldKind::kFkNone, "Invalid table order");
  335|     14|  static_assert(1 == FieldKind::kFkVarint, "Invalid table order");
  336|     14|  static_assert(2 == FieldKind::kFkPackedVarint, "Invalid table order");
  337|     14|  static_assert(3 == FieldKind::kFkFixed, "Invalid table order");
  338|     14|  static_assert(4 == FieldKind::kFkPackedFixed, "Invalid table order");
  339|     14|  static_assert(5 == FieldKind::kFkString, "Invalid table order");
  340|     14|  static_assert(6 == FieldKind::kFkMessage, "Invalid table order");
  341|     14|  static_assert(7 == FieldKind::kFkMap, "Invalid table order");
  342|       |
  343|     14|  static_assert(8 == (+field_layout::kSplitMask | FieldKind::kFkNone),
  344|     14|    "Invalid table order");
  345|     14|  static_assert(9 == (+field_layout::kSplitMask | FieldKind::kFkVarint),
  346|     14|    "Invalid table order");
  347|     14|  static_assert(10 == (+field_layout::kSplitMask | FieldKind::kFkPackedVarint),
  348|     14|    "Invalid table order");
  349|     14|  static_assert(11 == (+field_layout::kSplitMask | FieldKind::kFkFixed),
  350|     14|    "Invalid table order");
  351|     14|  static_assert(12 == (+field_layout::kSplitMask | FieldKind::kFkPackedFixed),
  352|     14|    "Invalid table order");
  353|     14|  static_assert(13 == (+field_layout::kSplitMask | FieldKind::kFkString),
  354|     14|    "Invalid table order");
  355|     14|  static_assert(14 == (+field_layout::kSplitMask | FieldKind::kFkMessage),
  356|     14|    "Invalid table order");
  357|     14|  static_assert(15 == (+field_layout::kSplitMask | FieldKind::kFkMap),
  358|     14|    "Invalid table order");
  359|       |
  360|     14|  TailCallParseFunc parse_fn = kMiniParseTable[field_type];
  361|     14|  if (export_called_function) *test_out = {parse_fn, tag, entry};
  ------------------
  |  Branch (361:7): [Folded - Ignored]
  ------------------
  362|       |
  363|     14|  PROTOBUF_MUSTTAIL return parse_fn(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  347|     14|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return parse_fn(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|     14|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  364|     14|}
_ZN6google8protobuf8internal8TcParser8MpVarintILb0EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1897|      2|PROTOBUF_NOINLINE const char* TcParser::MpVarint(PROTOBUF_TC_PARAM_DECL) {
 1898|      2|  const auto& entry = RefAt<FieldEntry>(table, data.entry_offset());
 1899|      2|  const uint16_t type_card = entry.type_card;
 1900|      2|  const uint16_t card = type_card & field_layout::kFcMask;
 1901|       |
 1902|       |  // Check for repeated parsing:
 1903|      2|  if (card == field_layout::kFcRepeated) {
  ------------------
  |  Branch (1903:7): [True: 0, False: 2]
  ------------------
 1904|      0|    PROTOBUF_MUSTTAIL return MpRepeatedVarint(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MpRepeatedVarint(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1905|      0|  }
 1906|       |  // Check for wire type mismatch:
 1907|      2|  if ((data.tag() & 7) != WireFormatLite::WIRETYPE_VARINT) {
  ------------------
  |  Branch (1907:7): [True: 0, False: 2]
  ------------------
 1908|      0|    PROTOBUF_MUSTTAIL return table->fallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return table->fallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1909|      0|  }
 1910|      2|  const uint16_t xform_val = type_card & field_layout::kTvMask;
 1911|      2|  const bool is_zigzag = xform_val == field_layout::kTvZigZag;
 1912|      2|  const bool is_validated_enum = xform_val & field_layout::kTvEnum;
 1913|       |
 1914|       |  // Parse the value:
 1915|      2|  const char* ptr2 = ptr;  // save for unknown enum case
 1916|      2|  uint64_t tmp;
 1917|      2|  ptr = ParseVarint(ptr, &tmp);
 1918|      2|  if (ptr == nullptr) {
  ------------------
  |  Branch (1918:7): [True: 0, False: 2]
  ------------------
 1919|      0|    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1920|      0|  }
 1921|       |
 1922|       |  // Transform and/or validate the value
 1923|      2|  uint16_t rep = type_card & field_layout::kRepMask;
 1924|      2|  if (rep == field_layout::kRep64Bits) {
  ------------------
  |  Branch (1924:7): [True: 0, False: 2]
  ------------------
 1925|      0|    if (is_zigzag) {
  ------------------
  |  Branch (1925:9): [True: 0, False: 0]
  ------------------
 1926|      0|      tmp = WireFormatLite::ZigZagDecode64(tmp);
 1927|      0|    }
 1928|      2|  } else if (rep == field_layout::kRep32Bits) {
  ------------------
  |  Branch (1928:14): [True: 2, False: 0]
  ------------------
 1929|      2|    if (is_validated_enum) {
  ------------------
  |  Branch (1929:9): [True: 2, False: 0]
  ------------------
 1930|      2|      if (!EnumIsValidAux(tmp, xform_val, *table->field_aux(&entry))) {
  ------------------
  |  Branch (1930:11): [True: 0, False: 2]
  ------------------
 1931|      0|        ptr = ptr2;
 1932|      0|        PROTOBUF_MUSTTAIL return MpUnknownEnumFallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                      PROTOBUF_MUSTTAIL return MpUnknownEnumFallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 1933|      0|      }
 1934|      2|    } else if (is_zigzag) {
  ------------------
  |  Branch (1934:16): [True: 0, False: 0]
  ------------------
 1935|      0|      tmp = WireFormatLite::ZigZagDecode32(static_cast<uint32_t>(tmp));
 1936|      0|    }
 1937|      2|  }
 1938|       |
 1939|       |  // Mark the field as present:
 1940|      2|  const bool is_oneof = card == field_layout::kFcOneof;
 1941|      2|  if (card == field_layout::kFcOptional) {
  ------------------
  |  Branch (1941:7): [True: 2, False: 0]
  ------------------
 1942|      2|    SetHas(entry, msg);
 1943|      2|  } else if (is_oneof) {
  ------------------
  |  Branch (1943:14): [True: 0, False: 0]
  ------------------
 1944|      0|    ChangeOneof(table, entry, data.tag() >> 3, ctx, msg);
 1945|      0|  }
 1946|       |
 1947|      2|  void* const base = MaybeGetSplitBase(msg, is_split, table);
 1948|      2|  if (rep == field_layout::kRep64Bits) {
  ------------------
  |  Branch (1948:7): [True: 0, False: 2]
  ------------------
 1949|      0|    RefAt<uint64_t>(base, entry.offset) = tmp;
 1950|      2|  } else if (rep == field_layout::kRep32Bits) {
  ------------------
  |  Branch (1950:14): [True: 2, False: 0]
  ------------------
 1951|      2|    RefAt<uint32_t>(base, entry.offset) = static_cast<uint32_t>(tmp);
 1952|      2|  } else {
 1953|      0|    ABSL_DCHECK_EQ(rep, static_cast<uint16_t>(field_layout::kRep8Bits));
  ------------------
  |  |   70|      0|  ABSL_DCHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   86|      0|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|      0|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1954|      0|    RefAt<bool>(base, entry.offset) = static_cast<bool>(tmp);
 1955|      0|  }
 1956|       |
 1957|      2|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      2|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      2|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1958|      2|}
generated_message_tctable_lite.cc:_ZN6google8protobuf8internal12_GLOBAL__N_16SetHasERKNS1_16TcParseTableBase10FieldEntryEPNS0_11MessageLiteE:
 1675|     14|inline void SetHas(const FieldEntry& entry, MessageLite* msg) {
 1676|     14|  auto has_idx = static_cast<uint32_t>(entry.has_idx);
 1677|     14|#if defined(__x86_64__) && defined(__GNUC__)
 1678|     14|  asm("bts %1, %0\n" : "+m"(*msg) : "r"(has_idx));
 1679|       |#else
 1680|       |  auto& hasblock = TcParser::RefAt<uint32_t>(msg, has_idx / 32 * 4);
 1681|       |  hasblock |= uint32_t{1} << (has_idx % 32);
 1682|       |#endif
 1683|     14|}
_ZN6google8protobuf8internal8TcParser8MpStringILb0EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 2129|     12|PROTOBUF_NOINLINE const char* TcParser::MpString(PROTOBUF_TC_PARAM_DECL) {
 2130|     12|  const auto& entry = RefAt<FieldEntry>(table, data.entry_offset());
 2131|     12|  const uint16_t type_card = entry.type_card;
 2132|     12|  const uint16_t card = type_card & field_layout::kFcMask;
 2133|     12|  const uint32_t decoded_wiretype = data.tag() & 7;
 2134|       |
 2135|     12|  if (decoded_wiretype != WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
  ------------------
  |  Branch (2135:7): [True: 0, False: 12]
  ------------------
 2136|      0|    PROTOBUF_MUSTTAIL return table->fallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return table->fallback(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 2137|      0|  }
 2138|     12|  if (card == field_layout::kFcRepeated) {
  ------------------
  |  Branch (2138:7): [True: 0, False: 12]
  ------------------
 2139|      0|    PROTOBUF_MUSTTAIL return MpRepeatedString(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MpRepeatedString(PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
 2140|      0|  }
 2141|     12|  const uint16_t xform_val = type_card & field_layout::kTvMask;
 2142|     12|  const uint16_t rep = type_card & field_layout::kRepMask;
 2143|       |
 2144|       |  // Mark the field as present:
 2145|     12|  const bool is_oneof = card == field_layout::kFcOneof;
 2146|     12|  bool need_init = false;
 2147|     12|  if (card == field_layout::kFcOptional) {
  ------------------
  |  Branch (2147:7): [True: 12, False: 0]
  ------------------
 2148|     12|    SetHas(entry, msg);
 2149|     12|  } else if (is_oneof) {
  ------------------
  |  Branch (2149:14): [True: 0, False: 0]
  ------------------
 2150|      0|    need_init = ChangeOneof(table, entry, data.tag() >> 3, ctx, msg);
 2151|      0|  }
 2152|       |
 2153|     12|  bool is_valid = false;
 2154|     12|  void* const base = MaybeGetSplitBase(msg, is_split, table);
 2155|     12|  switch (rep) {
 2156|     12|    case field_layout::kRepAString: {
  ------------------
  |  Branch (2156:5): [True: 12, False: 0]
  ------------------
 2157|     12|      auto& field = RefAt<ArenaStringPtr>(base, entry.offset);
 2158|     12|      if (need_init) field.InitDefault();
  ------------------
  |  Branch (2158:11): [True: 0, False: 12]
  ------------------
 2159|     12|      Arena* arena = msg->GetArenaForAllocation();
 2160|     12|      if (arena) {
  ------------------
  |  Branch (2160:11): [True: 0, False: 12]
  ------------------
 2161|      0|        ptr = ctx->ReadArenaString(ptr, &field, arena);
 2162|     12|      } else {
 2163|     12|        std::string* str = field.MutableNoCopy(nullptr);
 2164|     12|        ptr = InlineGreedyStringParser(str, ptr, ctx);
 2165|     12|      }
 2166|     12|      if (!ptr) break;
  ------------------
  |  Branch (2166:11): [True: 0, False: 12]
  ------------------
 2167|     12|      is_valid = MpVerifyUtf8(field.Get(), table, entry, xform_val);
 2168|     12|      break;
 2169|     12|    }
 2170|       |
 2171|       |
 2172|      0|    case field_layout::kRepCord: {
  ------------------
  |  Branch (2172:5): [True: 0, False: 12]
  ------------------
 2173|      0|      absl::Cord* field;
 2174|      0|      if (is_oneof) {
  ------------------
  |  Branch (2174:11): [True: 0, False: 0]
  ------------------
 2175|      0|        if (need_init) {
  ------------------
  |  Branch (2175:13): [True: 0, False: 0]
  ------------------
 2176|      0|          field = new absl::Cord;
 2177|      0|          RefAt<absl::Cord*>(msg, entry.offset) = field;
 2178|      0|          Arena* arena = msg->GetArenaForAllocation();
 2179|      0|          if (arena) arena->Own(field);
  ------------------
  |  Branch (2179:15): [True: 0, False: 0]
  ------------------
 2180|      0|        } else {
 2181|      0|          field = RefAt<absl::Cord*>(msg, entry.offset);
 2182|      0|        }
 2183|      0|      } else {
 2184|      0|        field = &RefAt<absl::Cord>(base, entry.offset);
 2185|      0|      }
 2186|      0|      ptr = InlineCordParser(field, ptr, ctx);
 2187|      0|      if (!ptr) break;
  ------------------
  |  Branch (2187:11): [True: 0, False: 0]
  ------------------
 2188|      0|      is_valid = MpVerifyUtf8(*field, table, entry, xform_val);
 2189|      0|      break;
 2190|      0|    }
 2191|       |
 2192|      0|    default:
  ------------------
  |  Branch (2192:5): [True: 0, False: 12]
  ------------------
 2193|      0|      PROTOBUF_ASSUME(false);
  ------------------
  |  | 1101|      0|#define PROTOBUF_ASSUME(pred) __builtin_assume(pred)
  ------------------
 2194|     12|  }
 2195|       |
 2196|     12|  if (ptr == nullptr || !is_valid) {
  ------------------
  |  Branch (2196:7): [True: 0, False: 12]
  |  Branch (2196:25): [True: 0, False: 12]
  ------------------
 2197|      0|    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 2198|      0|  }
 2199|     12|  PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|     12|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|     12|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 2200|     12|}
_ZN6google8protobuf8internal8TcParser27SingularParseMessageAuxImplIhLb0ELb1EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  417|     32|    PROTOBUF_TC_PARAM_DECL) {
  418|     32|  if (PROTOBUF_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  551|     32|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 32]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 32]
  |  |  ------------------
  ------------------
  419|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  420|      0|  }
  421|     32|  auto saved_tag = UnalignedLoad<TagType>(ptr);
  422|     32|  ptr += sizeof(TagType);
  423|     32|  hasbits |= (uint64_t{1} << data.hasbit_idx());
  424|     32|  SyncHasbits(msg, hasbits, table);
  425|     32|  auto& field = RefAt<MessageLite*>(msg, data.offset());
  426|       |
  427|     32|  if (aux_is_table) {
  ------------------
  |  Branch (427:7): [Folded - Ignored]
  ------------------
  428|     32|    const auto* inner_table = table->field_aux(data.aux_idx())->table;
  429|     32|    if (field == nullptr) {
  ------------------
  |  Branch (429:9): [True: 32, False: 0]
  ------------------
  430|     32|      field = inner_table->default_instance->New(msg->GetArenaForAllocation());
  431|     32|    }
  432|     32|    if (group_coding) {
  ------------------
  |  Branch (432:9): [Folded - Ignored]
  ------------------
  433|      0|      return ctx->ParseGroup<TcParser>(field, ptr, FastDecodeTag(saved_tag),
  434|      0|                                       inner_table);
  435|      0|    }
  436|     32|    return ctx->ParseMessage<TcParser>(field, ptr, inner_table);
  437|     32|  } else {
  438|      0|    if (field == nullptr) {
  ------------------
  |  Branch (438:9): [True: 0, False: 0]
  ------------------
  439|      0|      const MessageLite* default_instance =
  440|      0|          table->field_aux(data.aux_idx())->message_default();
  441|      0|      field = default_instance->New(msg->GetArenaForAllocation());
  442|      0|    }
  443|      0|    if (group_coding) {
  ------------------
  |  Branch (443:9): [Folded - Ignored]
  ------------------
  444|      0|      return ctx->ParseGroup(field, ptr, FastDecodeTag(saved_tag));
  445|      0|    }
  446|      0|    return ctx->ParseMessage(field, ptr);
  447|      0|  }
  448|     32|}
_ZN6google8protobuf8internal8TcParser27RepeatedParseMessageAuxImplIhLb0ELb1EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  506|    196|    PROTOBUF_TC_PARAM_DECL) {
  507|    196|  if (PROTOBUF_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  551|    196|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 196]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 196]
  |  |  ------------------
  ------------------
  508|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  509|      0|  }
  510|    196|  const auto expected_tag = UnalignedLoad<TagType>(ptr);
  511|    196|  const auto aux = *table->field_aux(data.aux_idx());
  512|    196|  auto& field = RefAt<RepeatedPtrFieldBase>(msg, data.offset());
  513|    702|  do {
  514|    702|    ptr += sizeof(TagType);
  515|    702|    MessageLite* submsg = field.Add<GenericTypeHandler<MessageLite>>(
  516|    702|        aux_is_table ? aux.table->default_instance : aux.message_default());
  ------------------
  |  Branch (516:9): [Folded - Ignored]
  ------------------
  517|    702|    if (aux_is_table) {
  ------------------
  |  Branch (517:9): [Folded - Ignored]
  ------------------
  518|    702|      if (group_coding) {
  ------------------
  |  Branch (518:11): [Folded - Ignored]
  ------------------
  519|      0|        ptr = ctx->ParseGroup<TcParser>(submsg, ptr,
  520|      0|                                        FastDecodeTag(expected_tag), aux.table);
  521|    702|      } else {
  522|    702|        ptr = ctx->ParseMessage<TcParser>(submsg, ptr, aux.table);
  523|    702|      }
  524|    702|    } else {
  525|      0|      if (group_coding) {
  ------------------
  |  Branch (525:11): [Folded - Ignored]
  ------------------
  526|      0|        ptr = ctx->ParseGroup(submsg, ptr, FastDecodeTag(expected_tag));
  527|      0|      } else {
  528|      0|        ptr = ctx->ParseMessage(submsg, ptr);
  529|      0|      }
  530|      0|    }
  531|    702|    if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) {
  ------------------
  |  |  551|    702|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 702]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 702]
  |  |  ------------------
  ------------------
  532|      0|      PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  533|      0|    }
  534|    702|    if (PROTOBUF_PREDICT_FALSE(!ctx->DataAvailable(ptr))) {
  ------------------
  |  |  551|    702|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 122, False: 580]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 122, False: 580]
  |  |  ------------------
  ------------------
  535|    122|      PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|    122|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                    PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|    122|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  536|    122|    }
  537|    702|  } while (UnalignedLoad<TagType>(ptr) == expected_tag);
  ------------------
  |  Branch (537:12): [True: 506, False: 74]
  ------------------
  538|       |
  539|    196|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|     74|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|     74|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  540|    196|}
_ZN6google8protobuf8internal8TcParser14SingularVarintIbtLb0EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  813|     20|    PROTOBUF_TC_PARAM_DECL) {
  814|     20|  if (PROTOBUF_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  551|     20|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 12, False: 8]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 12, False: 8]
  |  |  ------------------
  ------------------
  815|     12|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|     12|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|     12|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  816|     12|  }
  817|      8|  ptr += sizeof(TagType);  // Consume tag
  818|      8|  hasbits |= (uint64_t{1} << data.hasbit_idx());
  819|       |
  820|       |  // clang isn't smart enough to be able to only conditionally save
  821|       |  // registers to the stack, so we turn the integer-greater-than-128
  822|       |  // case into a separate routine.
  823|      8|  if (PROTOBUF_PREDICT_FALSE(static_cast<int8_t>(*ptr) < 0)) {
  ------------------
  |  |  551|      8|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 8]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 8]
  |  |  ------------------
  ------------------
  824|      0|    PROTOBUF_MUSTTAIL return SingularVarBigint<FieldType, TagType, zigzag>(
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
  825|      0|        PROTOBUF_TC_PARAM_PASS);
  ------------------
  |  |  854|      0|#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, data, table, hasbits
  ------------------
  826|      0|  }
  827|       |
  828|      8|  RefAt<FieldType>(msg, data.offset()) =
  829|      8|      ZigZagDecodeHelper<FieldType, zigzag>(static_cast<uint8_t>(*ptr++));
  830|      8|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      8|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      8|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  831|      8|}
generated_message_tctable_lite.cc:_ZN6google8protobuf8internal12_GLOBAL__N_118ZigZagDecodeHelperIbLb0EEET_S4_:
  786|      8|inline FieldType ZigZagDecodeHelper(FieldType value) {
  787|      8|  return static_cast<FieldType>(value);
  788|      8|}
_ZN6google8protobuf8internal8TcParser12FastVarintS1IjEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
  874|    622|    PROTOBUF_TC_PARAM_DECL) {
  875|    622|  using TagType = uint8_t;
  876|    622|  if (PROTOBUF_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  551|    622|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 622]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 622]
  |  |  ------------------
  ------------------
  877|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  878|      0|  }
  879|    622|  int64_t res;
  880|    622|  ptr = ShiftMixParseVarint<FieldType>(ptr + sizeof(TagType), res);
  881|    622|  if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) {
  ------------------
  |  |  551|    622|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 622]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 622]
  |  |  ------------------
  ------------------
  882|      0|    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  883|      0|  }
  884|    622|  hasbits |= (uint64_t{1} << data.hasbit_idx());
  885|    622|  RefAt<FieldType>(msg, data.offset()) = res;
  886|    622|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|    622|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|    622|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
  887|    622|}
generated_message_tctable_lite.cc:_ZN6google8protobuf8internal12_GLOBAL__N_111ParseVarintImEEPKcS5_PT_:
  712|      2|                                                      Type* value) {
  713|      2|  static_assert(sizeof(Type) == 4 || sizeof(Type) == 8,
  714|      2|                "Only [u]int32_t and [u]int64_t please");
  715|       |#ifdef __aarch64__
  716|       |  // The VarintParse parser has a faster implementation on ARM.
  717|       |  absl::conditional_t<sizeof(Type) == 4, uint32_t, uint64_t> tmp;
  718|       |  p = VarintParse(p, &tmp);
  719|       |  if (p != nullptr) {
  720|       |    *value = tmp;
  721|       |  }
  722|       |  return p;
  723|       |#endif
  724|      2|  int64_t res;
  725|      2|  p = ShiftMixParseVarint<Type>(p, res);
  726|      2|  *value = res;
  727|      2|  return p;
  728|      2|}
_ZN6google8protobuf8internal8TcParser22SingularEnumSmallRangeIhLh0EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1292|      2|    PROTOBUF_TC_PARAM_DECL) {
 1293|      2|  if (PROTOBUF_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  551|      2|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 2, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 2, False: 0]
  |  |  ------------------
  ------------------
 1294|      2|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      2|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      2|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1295|      2|  }
 1296|       |
 1297|      0|  uint8_t v = ptr[sizeof(TagType)];
 1298|      0|  if (PROTOBUF_PREDICT_FALSE(min > v || v > data.aux_idx())) {
  ------------------
  |  |  551|      0|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:64): [True: 0, False: 0]
  |  |  |  Branch (551:64): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1299|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1300|      0|  }
 1301|       |
 1302|      0|  RefAt<int32_t>(msg, data.offset()) = v;
 1303|      0|  ptr += sizeof(TagType) + 1;
 1304|      0|  hasbits |= (uint64_t{1} << data.hasbit_idx());
 1305|      0|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1306|      0|}
_ZN6google8protobuf8internal8TcParser22SingularEnumSmallRangeIhLh1EEEPKcPNS0_11MessageLiteES5_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1292|    774|    PROTOBUF_TC_PARAM_DECL) {
 1293|    774|  if (PROTOBUF_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  551|    774|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 774]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 774]
  |  |  ------------------
  ------------------
 1294|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1295|      0|  }
 1296|       |
 1297|    774|  uint8_t v = ptr[sizeof(TagType)];
 1298|    774|  if (PROTOBUF_PREDICT_FALSE(min > v || v > data.aux_idx())) {
  ------------------
  |  |  551|  1.54k|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 774]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:64): [True: 0, False: 774]
  |  |  |  Branch (551:64): [True: 0, False: 774]
  |  |  ------------------
  ------------------
 1299|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1300|      0|  }
 1301|       |
 1302|    774|  RefAt<int32_t>(msg, data.offset()) = v;
 1303|    774|  ptr += sizeof(TagType) + 1;
 1304|    774|  hasbits |= (uint64_t{1} << data.hasbit_idx());
 1305|    774|  PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|    774|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|    774|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1306|    774|}
generated_message_tctable_lite.cc:_ZN6google8protobuf8internal12_GLOBAL__N_117ReadStringNoArenaEPNS0_11MessageLiteEPKcPNS1_12ParseContextEjPKNS1_16TcParseTableBaseERNS1_14ArenaStringPtrE:
 1467|    942|                              ArenaStringPtr& field) {
 1468|    942|  int size = ReadSize(&ptr);
 1469|    942|  if (!ptr) return nullptr;
  ------------------
  |  Branch (1469:7): [True: 0, False: 942]
  ------------------
 1470|    942|  return ctx->ReadString(ptr, size, field.MutableNoCopy(nullptr));
 1471|    942|}
_ZN6google8protobuf8internal8TcParser14SingularStringIhNS1_14ArenaStringPtrELNS2_8Utf8TypeE2EEEPKcPNS0_11MessageLiteES7_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1482|    930|    PROTOBUF_TC_PARAM_DECL) {
 1483|    930|  if (PROTOBUF_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  551|    930|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 930]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 930]
  |  |  ------------------
  ------------------
 1484|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1485|      0|  }
 1486|    930|  auto saved_tag = UnalignedLoad<TagType>(ptr);
 1487|    930|  ptr += sizeof(TagType);
 1488|    930|  hasbits |= (uint64_t{1} << data.hasbit_idx());
 1489|    930|  auto& field = RefAt<FieldType>(msg, data.offset());
 1490|    930|  auto arena = msg->GetArenaForAllocation();
 1491|    930|  if (arena) {
  ------------------
  |  Branch (1491:7): [True: 0, False: 930]
  ------------------
 1492|      0|    ptr =
 1493|      0|        ReadStringIntoArena(msg, ptr, ctx, data.aux_idx(), table, field, arena);
 1494|    930|  } else {
 1495|    930|    ptr = ReadStringNoArena(msg, ptr, ctx, data.aux_idx(), table, field);
 1496|    930|  }
 1497|    930|  if (ptr == nullptr) {
  ------------------
  |  Branch (1497:7): [True: 0, False: 930]
  ------------------
 1498|      0|    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1499|      0|  }
 1500|    930|  switch (utf8) {
 1501|      0|    case kNoUtf8:
  ------------------
  |  Branch (1501:5): [True: 0, False: 930]
  ------------------
 1502|      0|#ifdef NDEBUG
 1503|    930|    case kUtf8ValidateOnly:
  ------------------
  |  Branch (1503:5): [True: 930, False: 0]
  ------------------
 1504|    930|#endif
 1505|    930|      PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|    930|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                    PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|    930|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1506|      0|    default:
  ------------------
  |  Branch (1506:5): [True: 0, False: 930]
  ------------------
 1507|      0|      if (PROTOBUF_PREDICT_TRUE(IsValidUTF8(field))) {
  ------------------
  |  |  550|      0|# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (550:35): [True: 0, False: 0]
  |  |  |  Branch (550:53): [Folded - Ignored]
  |  |  |  Branch (550:62): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1508|      0|        PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                      PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1509|      0|      }
 1510|      0|      ReportFastUtf8Error(FastDecodeTag(saved_tag), table);
 1511|      0|      if (utf8 == kUtf8) {
  ------------------
  |  Branch (1511:11): [Folded - Ignored]
  ------------------
 1512|      0|        PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                      PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1513|      0|      }
 1514|      0|      PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                    PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1515|    930|  }
 1516|    930|}
_ZN6google8protobuf8internal8TcParser14SingularStringItNS1_14ArenaStringPtrELNS2_8Utf8TypeE2EEEPKcPNS0_11MessageLiteES7_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1482|     12|    PROTOBUF_TC_PARAM_DECL) {
 1483|     12|  if (PROTOBUF_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  551|     12|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 12]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 12]
  |  |  ------------------
  ------------------
 1484|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1485|      0|  }
 1486|     12|  auto saved_tag = UnalignedLoad<TagType>(ptr);
 1487|     12|  ptr += sizeof(TagType);
 1488|     12|  hasbits |= (uint64_t{1} << data.hasbit_idx());
 1489|     12|  auto& field = RefAt<FieldType>(msg, data.offset());
 1490|     12|  auto arena = msg->GetArenaForAllocation();
 1491|     12|  if (arena) {
  ------------------
  |  Branch (1491:7): [True: 0, False: 12]
  ------------------
 1492|      0|    ptr =
 1493|      0|        ReadStringIntoArena(msg, ptr, ctx, data.aux_idx(), table, field, arena);
 1494|     12|  } else {
 1495|     12|    ptr = ReadStringNoArena(msg, ptr, ctx, data.aux_idx(), table, field);
 1496|     12|  }
 1497|     12|  if (ptr == nullptr) {
  ------------------
  |  Branch (1497:7): [True: 0, False: 12]
  ------------------
 1498|      0|    PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1499|      0|  }
 1500|     12|  switch (utf8) {
 1501|      0|    case kNoUtf8:
  ------------------
  |  Branch (1501:5): [True: 0, False: 12]
  ------------------
 1502|      0|#ifdef NDEBUG
 1503|     12|    case kUtf8ValidateOnly:
  ------------------
  |  Branch (1503:5): [True: 12, False: 0]
  ------------------
 1504|     12|#endif
 1505|     12|      PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|     12|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                    PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|     12|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1506|      0|    default:
  ------------------
  |  Branch (1506:5): [True: 0, False: 12]
  ------------------
 1507|      0|      if (PROTOBUF_PREDICT_TRUE(IsValidUTF8(field))) {
  ------------------
  |  |  550|      0|# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (550:35): [True: 0, False: 0]
  |  |  |  Branch (550:53): [Folded - Ignored]
  |  |  |  Branch (550:62): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1508|      0|        PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                      PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1509|      0|      }
 1510|      0|      ReportFastUtf8Error(FastDecodeTag(saved_tag), table);
 1511|      0|      if (utf8 == kUtf8) {
  ------------------
  |  Branch (1511:11): [Folded - Ignored]
  ------------------
 1512|      0|        PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                      PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1513|      0|      }
 1514|      0|      PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                    PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1515|     12|  }
 1516|     12|}
_ZN6google8protobuf8internal8TcParser14RepeatedStringIhNS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEELNS2_8Utf8TypeE2EEEPKcPNS0_11MessageLiteESF_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEm:
 1588|      2|    PROTOBUF_TC_PARAM_DECL) {
 1589|      2|  if (PROTOBUF_PREDICT_FALSE(data.coded_tag<TagType>() != 0)) {
  ------------------
  |  |  551|      2|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 2]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 1590|      0|    PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                  PROTOBUF_MUSTTAIL return MiniParse(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1591|      0|  }
 1592|      2|  const auto expected_tag = UnalignedLoad<TagType>(ptr);
 1593|      2|  auto& field = RefAt<FieldType>(msg, data.offset());
 1594|       |
 1595|      2|  const auto validate_last_string = [expected_tag, table, &field] {
 1596|      2|    switch (utf8) {
 1597|      2|      case kNoUtf8:
 1598|      2|#ifdef NDEBUG
 1599|      2|      case kUtf8ValidateOnly:
 1600|      2|#endif
 1601|      2|        return true;
 1602|      2|      default:
 1603|      2|        if (PROTOBUF_PREDICT_TRUE(
 1604|      2|                utf8_range::IsStructurallyValid(field[field.size() - 1]))) {
 1605|      2|          return true;
 1606|      2|        }
 1607|      2|        ReportFastUtf8Error(FastDecodeTag(expected_tag), table);
 1608|      2|        if (utf8 == kUtf8) return false;
 1609|      2|        return true;
 1610|      2|    }
 1611|      2|  };
 1612|       |
 1613|      2|  auto* arena = field.GetOwningArena();
 1614|      2|  SerialArena* serial_arena;
 1615|      2|  if (PROTOBUF_PREDICT_TRUE(arena != nullptr &&
  ------------------
  |  |  550|      4|# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (550:35): [True: 0, False: 2]
  |  |  |  Branch (550:53): [Folded - Ignored]
  |  |  |  Branch (550:63): [True: 0, False: 2]
  |  |  |  Branch (550:63): [True: 0, False: 0]
  |  |  |  Branch (550:63): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1616|      2|                            arena->impl_.GetSerialArenaFast(&serial_arena) &&
 1617|      2|                            field.PrepareForParse())) {
 1618|      0|    do {
 1619|      0|      ptr += sizeof(TagType);
 1620|      0|      ptr = ParseRepeatedStringOnce(ptr, arena, serial_arena, ctx, field);
 1621|       |
 1622|      0|      if (PROTOBUF_PREDICT_FALSE(ptr == nullptr || !validate_last_string())) {
  ------------------
  |  |  551|      0|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:64): [True: 0, False: 0]
  |  |  |  Branch (551:64): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1623|      0|        PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                      PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1624|      0|      }
 1625|      0|      if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (1625:11): [True: 0, False: 0]
  ------------------
 1626|      0|    } while (UnalignedLoad<TagType>(ptr) == expected_tag);
  ------------------
  |  Branch (1626:14): [True: 0, False: 0]
  ------------------
 1627|      2|  } else {
 1628|      4|    do {
 1629|      4|      ptr += sizeof(TagType);
 1630|      4|      std::string* str = field.Add();
 1631|      4|      ptr = InlineGreedyStringParser(str, ptr, ctx);
 1632|      4|      if (PROTOBUF_PREDICT_FALSE(ptr == nullptr || !validate_last_string())) {
  ------------------
  |  |  551|      8|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 4]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:64): [True: 0, False: 4]
  |  |  |  Branch (551:64): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 1633|      0|        PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      0|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                      PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      0|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1634|      0|      }
 1635|      4|      if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (1635:11): [True: 0, False: 4]
  ------------------
 1636|      4|    } while (UnalignedLoad<TagType>(ptr) == expected_tag);
  ------------------
  |  Branch (1636:14): [True: 2, False: 2]
  ------------------
 1637|      2|  }
 1638|      2|  PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  347|      2|#define PROTOBUF_MUSTTAIL [[clang::musttail]]
  ------------------
                PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
  ------------------
  |  |  867|      2|  msg, ptr, ctx, ::google::protobuf::internal::TcFieldData::DefaultInit(), table, hasbits
  ------------------
 1639|      2|}
_ZZN6google8protobuf8internal8TcParser14RepeatedStringIhNS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEELNS2_8Utf8TypeE2EEEPKcPNS0_11MessageLiteESF_PNS1_12ParseContextENS1_11TcFieldDataEPKNS1_16TcParseTableBaseEmENKUlvE_clEv:
 1595|      4|  const auto validate_last_string = [expected_tag, table, &field] {
 1596|      4|    switch (utf8) {
 1597|      0|      case kNoUtf8:
  ------------------
  |  Branch (1597:7): [True: 0, False: 4]
  ------------------
 1598|      0|#ifdef NDEBUG
 1599|      4|      case kUtf8ValidateOnly:
  ------------------
  |  Branch (1599:7): [True: 4, False: 0]
  ------------------
 1600|      4|#endif
 1601|      4|        return true;
 1602|      0|      default:
  ------------------
  |  Branch (1602:7): [True: 0, False: 4]
  ------------------
 1603|      0|        if (PROTOBUF_PREDICT_TRUE(
  ------------------
  |  |  550|      0|# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (550:35): [True: 0, False: 0]
  |  |  |  Branch (550:53): [Folded - Ignored]
  |  |  |  Branch (550:62): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1604|      0|                utf8_range::IsStructurallyValid(field[field.size() - 1]))) {
 1605|      0|          return true;
 1606|      0|        }
 1607|      0|        ReportFastUtf8Error(FastDecodeTag(expected_tag), table);
 1608|      0|        if (utf8 == kUtf8) return false;
  ------------------
  |  Branch (1608:13): [Folded - Ignored]
  ------------------
 1609|      0|        return true;
 1610|      4|    }
 1611|      4|  };

_ZN6google8protobuf8internal24InitProtobufDefaultsSlowEv:
   84|      2|void InitProtobufDefaultsSlow() {
   85|      2|  static bool is_inited = InitProtobufDefaultsImpl();
   86|      2|  (void)is_inited;
   87|      2|}
generated_message_util.cc:_ZN6google8protobuf8internalL24InitProtobufDefaultsImplEv:
   75|      2|static bool InitProtobufDefaultsImpl() {
   76|      2|  fixed_address_empty_string.DefaultConstruct();
   77|      2|  OnShutdownDestroyString(fixed_address_empty_string.get_mutable());
   78|       |
   79|       |
   80|      2|  init_protobuf_defaults_state.store(true, std::memory_order_release);
   81|      2|  return true;
   82|      2|}

_ZN6google8protobuf2io19LimitingInputStreamC2EPNS1_19ZeroCopyInputStreamEl:
  426|  54.3k|    : input_(input), limit_(limit) {
  427|  54.3k|  prior_bytes_read_ = input_->ByteCount();
  428|  54.3k|}
_ZN6google8protobuf2io19LimitingInputStreamD2Ev:
  430|  54.3k|LimitingInputStream::~LimitingInputStream() {
  431|       |  // If we overshot the limit, back up.
  432|  54.3k|  if (limit_ < 0) input_->BackUp(-limit_);
  ------------------
  |  Branch (432:7): [True: 0, False: 54.3k]
  ------------------
  433|  54.3k|}

_ZN6google8protobuf14MessageFactory29InternalRegisterGeneratedFileEPKNS0_8internal15DescriptorTableE:
  379|     12|    const google::protobuf::internal::DescriptorTable* table) {
  380|     12|  GeneratedMessageFactory::singleton()->RegisterFile(table);
  381|     12|}
message.cc:_ZN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory9singletonEv:
  302|     12|GeneratedMessageFactory* GeneratedMessageFactory::singleton() {
  303|     12|  static auto instance =
  304|     12|      internal::OnShutdownDelete(new GeneratedMessageFactory);
  305|     12|  return instance;
  306|     12|}
message.cc:_ZN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory12RegisterFileEPKNS0_8internal15DescriptorTableE:
  309|     12|    const google::protobuf::internal::DescriptorTable* table) {
  310|     12|  if (!files_.insert(table).second) {
  ------------------
  |  Branch (310:7): [True: 0, False: 12]
  ------------------
  311|      0|    ABSL_LOG(FATAL) << "File is already registered: " << table->filename;
  ------------------
  |  |   38|      0|#define ABSL_LOG(severity) ABSL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   24|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |   25|      0|      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
  |  |  ------------------
  ------------------
  312|      0|  }
  313|     12|}
message.cc:_ZNK6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory20DescriptorByNameHashclEPKNS0_8internal15DescriptorTableE:
  265|     20|    size_t operator()(const google::protobuf::internal::DescriptorTable* t) const {
  266|     20|      return absl::HashOf(absl::string_view{t->filename});
  267|     20|    }

_ZN6google8protobuf8internal13MergeFromImplILb0EEEbN4absl12lts_2023012511string_viewEPNS0_11MessageLiteENS6_10ParseFlagsE:
  134|     12|                   MessageLite::ParseFlags parse_flags) {
  135|     12|  const char* ptr;
  136|     12|  internal::ParseContext ctx(io::CodedInputStream::GetDefaultRecursionLimit(),
  137|     12|                             aliasing, &ptr, input);
  138|     12|  ptr = msg->_InternalParse(ptr, &ctx);
  139|       |  // ctx has an explicit limit set (length of string_view).
  140|     12|  if (PROTOBUF_PREDICT_TRUE(ptr && ctx.EndedAtLimit())) {
  ------------------
  |  |  550|     24|# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (550:35): [True: 12, False: 0]
  |  |  |  Branch (550:53): [Folded - Ignored]
  |  |  |  Branch (550:63): [True: 12, False: 0]
  |  |  |  Branch (550:63): [True: 12, False: 0]
  |  |  ------------------
  ------------------
  141|     12|    return CheckFieldPresence(ctx, *msg, parse_flags);
  142|     12|  }
  143|      0|  return false;
  144|     12|}
_ZN6google8protobuf11MessageLite14ParseFromArrayEPKvi:
  320|     12|bool MessageLite::ParseFromArray(const void* data, int size) {
  321|     12|  return ParseFrom<kParse>(as_string_view(data, size));
  322|     12|}
_ZN6google8protobuf8internal22NewFromPrototypeHelperEPKNS0_11MessageLiteEPNS0_5ArenaE:
  627|    702|                                    Arena* arena) {
  628|    702|  return prototype->New(arena);
  629|    702|}
_ZN6google8protobuf8internal13OnShutdownRunEPFvPKvES3_:
  698|      6|void OnShutdownRun(void (*f)(const void*), const void* arg) {
  699|      6|  auto shutdown_data = ShutdownData::get();
  700|      6|  absl::MutexLock lock(&shutdown_data->mutex);
  701|      6|  shutdown_data->functions.push_back(std::make_pair(f, arg));
  702|      6|}
message_lite.cc:_ZN6google8protobuf12_GLOBAL__N_118CheckFieldPresenceERKNS0_8internal12ParseContextERKNS0_11MessageLiteENS6_10ParseFlagsE:
  116|     12|                               MessageLite::ParseFlags parse_flags) {
  117|     12|  (void)ctx;  // Parameter is used by Google-internal code.
  118|     12|  if (PROTOBUF_PREDICT_FALSE((parse_flags & MessageLite::kMergePartial) != 0)) {
  ------------------
  |  |  551|     12|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 12]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 12]
  |  |  ------------------
  ------------------
  119|      0|    return true;
  120|      0|  }
  121|     12|  return msg.IsInitializedWithErrors();
  122|     12|}
message_lite.cc:_ZN6google8protobuf12_GLOBAL__N_114as_string_viewEPKvi:
  109|     12|inline absl::string_view as_string_view(const void* data, int size) {
  110|     12|  return absl::string_view(static_cast<const char*>(data), size);
  111|     12|}
_ZN6google8protobuf8internal12ShutdownData3getEv:
  680|      6|  static ShutdownData* get() {
  681|      6|    static auto* data = new ShutdownData;
  682|      6|    return data;
  683|      6|  }

_ZN6google8protobuf8internal18EpsCopyInputStream12DoneFallbackEii:
  172|     10|                                                              int depth) {
  173|       |  // Did we exceeded the limit (parse error).
  174|     10|  if (PROTOBUF_PREDICT_FALSE(overrun > limit_)) return {nullptr, true};
  ------------------
  |  |  551|     10|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 10]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 10]
  |  |  ------------------
  ------------------
  175|     10|  ABSL_DCHECK(overrun != limit_);  // Guaranteed by caller.
  ------------------
  |  |   43|     10|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     10|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     20|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     10|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     20|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     20|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  176|     10|  ABSL_DCHECK(overrun < limit_);   // Follows from above
  ------------------
  |  |   43|     10|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     10|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     20|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     10|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     20|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     20|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  177|       |  // TODO(gerbens) Instead of this dcheck we could just assign, and remove
  178|       |  // updating the limit_end from PopLimit, ie.
  179|       |  // limit_end_ = buffer_end_ + (std::min)(0, limit_);
  180|       |  // if (ptr < limit_end_) return {ptr, false};
  181|     10|  ABSL_DCHECK(limit_end_ == buffer_end_ + (std::min)(0, limit_));
  ------------------
  |  |   43|     10|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     10|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     20|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     10|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     20|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     20|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  182|       |  // At this point we know the following assertion holds.
  183|     10|  ABSL_DCHECK_GT(limit_, 0);
  ------------------
  |  |   80|     10|  ABSL_DCHECK_GT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   96|     10|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     10|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     10|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  184|     10|  ABSL_DCHECK(limit_end_ == buffer_end_);  // because limit_ > 0
  ------------------
  |  |   43|     10|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     10|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     10|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     10|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     10|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     10|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  185|     10|  const char* p;
  186|     10|  do {
  187|       |    // We are past the end of buffer_end_, in the slop region.
  188|     10|    ABSL_DCHECK_GE(overrun, 0);
  ------------------
  |  |   78|     10|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|     10|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     10|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     10|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  189|     10|    p = NextBuffer(overrun, depth);
  190|     10|    if (p == nullptr) {
  ------------------
  |  Branch (190:9): [True: 0, False: 10]
  ------------------
  191|       |      // We are at the end of the stream
  192|      0|      if (PROTOBUF_PREDICT_FALSE(overrun != 0)) return {nullptr, true};
  ------------------
  |  |  551|      0|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  193|      0|      ABSL_DCHECK_GT(limit_, 0);
  ------------------
  |  |   80|      0|  ABSL_DCHECK_GT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   96|      0|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|      0|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  194|      0|      limit_end_ = buffer_end_;
  195|       |      // Distinguish ending on a pushed limit or ending on end-of-stream.
  196|      0|      SetEndOfStream();
  197|      0|      return {buffer_end_, true};
  198|      0|    }
  199|     10|    limit_ -= buffer_end_ - p;  // Adjust limit_ relative to new anchor
  200|     10|    p += overrun;
  201|     10|    overrun = p - buffer_end_;
  202|     10|  } while (overrun >= 0);
  ------------------
  |  Branch (202:12): [True: 0, False: 10]
  ------------------
  203|     10|  limit_end_ = buffer_end_ + std::min(0, limit_);
  204|     10|  return {p, false};
  205|     10|}
_ZN6google8protobuf8internal16ReadSizeFallbackEPKcj:
  401|     56|std::pair<const char*, int32_t> ReadSizeFallback(const char* p, uint32_t res) {
  402|     56|  for (std::uint32_t i = 1; i < 4; i++) {
  ------------------
  |  Branch (402:29): [True: 56, False: 0]
  ------------------
  403|     56|    uint32_t byte = static_cast<uint8_t>(p[i]);
  404|     56|    res += (byte - 1) << (7 * i);
  405|     56|    if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
  ------------------
  |  |  550|     56|# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (550:35): [True: 56, False: 0]
  |  |  |  Branch (550:53): [Folded - Ignored]
  |  |  |  Branch (550:62): [True: 56, False: 0]
  |  |  ------------------
  ------------------
  406|     56|      return {p + i + 1, res};
  407|     56|    }
  408|     56|  }
  409|      0|  std::uint32_t byte = static_cast<uint8_t>(p[4]);
  410|      0|  if (PROTOBUF_PREDICT_FALSE(byte >= 8)) return {nullptr, 0};  // size >= 2gb
  ------------------
  |  |  551|      0|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  411|      0|  res += (byte - 1) << 28;
  412|       |  // Protect against sign integer overflow in PushLimit. Limits are relative
  413|       |  // to buffer ends and ptr could potential be kSlopBytes beyond a buffer end.
  414|       |  // To protect against overflow we reject limits absurdly close to INT_MAX.
  415|      0|  if (PROTOBUF_PREDICT_FALSE(res > INT_MAX - ParseContext::kSlopBytes)) {
  ------------------
  |  |  551|      0|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (551:36): [True: 0, False: 0]
  |  |  |  Branch (551:54): [Folded - Ignored]
  |  |  |  Branch (551:63): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  416|      0|    return {nullptr, 0};
  417|      0|  }
  418|      0|  return {p + 5, res};
  419|      0|}
_ZN6google8protobuf8internal24InlineGreedyStringParserEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKcPNS1_12ParseContextE:
  442|     16|                                     ParseContext* ctx) {
  443|     16|  int size = ReadSize(&ptr);
  444|     16|  if (!ptr) return nullptr;
  ------------------
  |  Branch (444:7): [True: 0, False: 16]
  ------------------
  445|     16|  return ctx->ReadString(ptr, size, s);
  446|     16|}
_ZN6google8protobuf8internal18EpsCopyInputStream10NextBufferEii:
  102|     10|const char* EpsCopyInputStream::NextBuffer(int overrun, int depth) {
  103|     10|  if (next_chunk_ == nullptr) return nullptr;  // We've reached end of stream.
  ------------------
  |  Branch (103:7): [True: 0, False: 10]
  ------------------
  104|     10|  if (next_chunk_ != patch_buffer_) {
  ------------------
  |  Branch (104:7): [True: 0, False: 10]
  ------------------
  105|      0|    ABSL_DCHECK(size_ > kSlopBytes);
  ------------------
  |  |   43|      0|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|      0|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  106|       |    // The chunk is large enough to be used directly
  107|      0|    buffer_end_ = next_chunk_ + size_ - kSlopBytes;
  108|      0|    auto res = next_chunk_;
  109|      0|    next_chunk_ = patch_buffer_;
  110|      0|    if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
  ------------------
  |  Branch (110:9): [True: 0, False: 0]
  ------------------
  111|      0|    return res;
  112|      0|  }
  113|       |  // Move the slop bytes of previous buffer to start of the patch buffer.
  114|       |  // Note we must use memmove because the previous buffer could be part of
  115|       |  // patch_buffer_.
  116|     10|  std::memmove(patch_buffer_, buffer_end_, kSlopBytes);
  117|     10|  if (overall_limit_ > 0 &&
  ------------------
  |  Branch (117:7): [True: 0, False: 10]
  ------------------
  118|     10|      (depth < 0 || !ParseEndsInSlopRegion(patch_buffer_, overrun, depth))) {
  ------------------
  |  Branch (118:8): [True: 0, False: 0]
  |  Branch (118:21): [True: 0, False: 0]
  ------------------
  119|      0|    const void* data;
  120|       |    // ZeroCopyInputStream indicates Next may return 0 size buffers. Hence
  121|       |    // we loop.
  122|      0|    while (StreamNext(&data)) {
  ------------------
  |  Branch (122:12): [True: 0, False: 0]
  ------------------
  123|      0|      if (size_ > kSlopBytes) {
  ------------------
  |  Branch (123:11): [True: 0, False: 0]
  ------------------
  124|       |        // We got a large chunk
  125|      0|        std::memcpy(patch_buffer_ + kSlopBytes, data, kSlopBytes);
  126|      0|        next_chunk_ = static_cast<const char*>(data);
  127|      0|        buffer_end_ = patch_buffer_ + kSlopBytes;
  128|      0|        if (aliasing_ >= kNoDelta) aliasing_ = kOnPatch;
  ------------------
  |  Branch (128:13): [True: 0, False: 0]
  ------------------
  129|      0|        return patch_buffer_;
  130|      0|      } else if (size_ > 0) {
  ------------------
  |  Branch (130:18): [True: 0, False: 0]
  ------------------
  131|      0|        std::memcpy(patch_buffer_ + kSlopBytes, data, size_);
  132|      0|        next_chunk_ = patch_buffer_;
  133|      0|        buffer_end_ = patch_buffer_ + size_;
  134|      0|        if (aliasing_ >= kNoDelta) aliasing_ = kOnPatch;
  ------------------
  |  Branch (134:13): [True: 0, False: 0]
  ------------------
  135|      0|        return patch_buffer_;
  136|      0|      }
  137|      0|      ABSL_DCHECK(size_ == 0) << size_;
  ------------------
  |  |   43|      0|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|      0|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  138|      0|    }
  139|      0|    overall_limit_ = 0;  // Next failed, no more needs for next
  140|      0|  }
  141|       |  // End of stream or array
  142|     10|  if (aliasing_ == kNoDelta) {
  ------------------
  |  Branch (142:7): [True: 0, False: 10]
  ------------------
  143|       |    // If there is no more block and aliasing is true, the previous block
  144|       |    // is still valid and we can alias. We have users relying on string_view's
  145|       |    // obtained from protos to outlive the proto, when the parse was from an
  146|       |    // array. This guarantees string_view's are always aliased if parsed from
  147|       |    // an array.
  148|      0|    aliasing_ = reinterpret_cast<std::uintptr_t>(buffer_end_) -
  149|      0|                reinterpret_cast<std::uintptr_t>(patch_buffer_);
  150|      0|  }
  151|     10|  next_chunk_ = nullptr;
  152|     10|  buffer_end_ = patch_buffer_ + kSlopBytes;
  153|     10|  size_ = 0;
  154|     10|  return patch_buffer_;
  155|     10|}

_ZN6google8protobuf8internal20RepeatedPtrFieldBase14InternalExtendEi:
   50|    390|void** RepeatedPtrFieldBase::InternalExtend(int extend_amount) {
   51|    390|  int new_size = current_size_ + extend_amount;
   52|    390|  if (total_size_ >= new_size) {
  ------------------
  |  Branch (52:7): [True: 0, False: 390]
  ------------------
   53|       |    // N.B.: rep_ is non-nullptr because extend_amount is always > 0, hence
   54|       |    // total_size must be non-zero since it is lower-bounded by new_size.
   55|      0|    return &rep_->elements[current_size_];
   56|      0|  }
   57|    390|  Rep* old_rep = rep_;
   58|    390|  Arena* arena = GetOwningArena();
   59|    390|  new_size = internal::CalculateReserveSize<void*, kRepHeaderSize>(total_size_,
   60|    390|                                                                   new_size);
   61|    390|  ABSL_CHECK_LE(static_cast<int64_t>(new_size),
  ------------------
  |  |   50|      0|  ABSL_CHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   52|    390|  ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|    390|  while (                                                                      \
  |  |  |  |  |  |   62|    390|      ::std::string* absl_log_internal_check_op_result ABSL_ATTRIBUTE_UNUSED = \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (62:22): [True: 0, False: 390]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    390|          ::absl::log_internal::name##Impl(                                    \
  |  |  |  |  |  |   64|    390|              ::absl::log_internal::GetReferenceableValue(val1),               \
  |  |  |  |  |  |   65|    390|              ::absl::log_internal::GetReferenceableValue(val2),               \
  |  |  |  |  |  |   66|    390|              ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text                 \
  |  |  |  |  |  |   67|    390|                                                     " " #op " " val2_text)))  \
  |  |  |  |  |  |   68|    390|  ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_op_result).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   62|      0|                static_cast<int64_t>(
   63|      0|                    (std::numeric_limits<size_t>::max() - kRepHeaderSize) /
   64|      0|                    sizeof(old_rep->elements[0])))
   65|      0|      << "Requested size is too large to fit into size_t.";
   66|    390|  size_t bytes = kRepHeaderSize + sizeof(old_rep->elements[0]) * new_size;
   67|    390|  if (arena == nullptr) {
  ------------------
  |  Branch (67:7): [True: 390, False: 0]
  ------------------
   68|    390|    internal::SizedPtr res = internal::AllocateAtLeast(bytes);
   69|    390|    new_size = (res.n - kRepHeaderSize) / sizeof(old_rep->elements[0]);
   70|    390|    rep_ = reinterpret_cast<Rep*>(res.p);
   71|    390|  } else {
   72|      0|    rep_ = reinterpret_cast<Rep*>(Arena::CreateArray<char>(arena, bytes));
   73|      0|  }
   74|    390|  const int old_total_size = total_size_;
   75|    390|  total_size_ = new_size;
   76|    390|  if (old_rep) {
  ------------------
  |  Branch (76:7): [True: 192, False: 198]
  ------------------
   77|    192|    if (old_rep->allocated_size > 0) {
  ------------------
  |  Branch (77:9): [True: 192, False: 0]
  ------------------
   78|    192|      memcpy(rep_->elements, old_rep->elements,
   79|    192|             old_rep->allocated_size * sizeof(rep_->elements[0]));
   80|    192|    }
   81|    192|    rep_->allocated_size = old_rep->allocated_size;
   82|       |
   83|    192|    const size_t old_size =
   84|    192|        old_total_size * sizeof(rep_->elements[0]) + kRepHeaderSize;
   85|    192|    if (arena == nullptr) {
  ------------------
  |  Branch (85:9): [True: 192, False: 0]
  ------------------
   86|    192|      internal::SizedDelete(old_rep, old_size);
   87|    192|    } else {
   88|      0|      arena_->ReturnArrayMemory(old_rep, old_size);
   89|      0|    }
   90|    198|  } else {
   91|    198|    rep_->allocated_size = 0;
   92|    198|  }
   93|    390|  return &rep_->elements[current_size_];
   94|    390|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase13DestroyProtosEv:
  102|    196|void RepeatedPtrFieldBase::DestroyProtos() {
  103|    196|  ABSL_DCHECK(rep_);
  ------------------
  |  |   43|    196|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|    196|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|    196|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|    196|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|    196|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|    196|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  104|    196|  ABSL_DCHECK(arena_ == nullptr);
  ------------------
  |  |   43|    196|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|    196|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|    392|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|    196|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|    392|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|    392|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  105|    196|  int n = rep_->allocated_size;
  106|    196|  void* const* elements = rep_->elements;
  107|    898|  for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (107:19): [True: 702, False: 196]
  ------------------
  108|    702|    delete static_cast<MessageLite*>(elements[i]);
  109|    702|  }
  110|    196|  const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
  111|    196|  internal::SizedDelete(rep_, size);
  112|    196|  rep_ = nullptr;
  113|    196|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase18AddOutOfLineHelperEPv:
  115|    706|void* RepeatedPtrFieldBase::AddOutOfLineHelper(void* obj) {
  116|    706|  if (!rep_ || rep_->allocated_size == total_size_) {
  ------------------
  |  Branch (116:7): [True: 198, False: 508]
  |  Branch (116:16): [True: 192, False: 316]
  ------------------
  117|    390|    InternalExtend(1);  // Equivalent to "Reserve(total_size_ + 1)"
  118|    390|  }
  119|    706|  ++rep_->allocated_size;
  120|    706|  rep_->elements[ExchangeCurrentSize(current_size_ + 1)] = obj;
  121|    706|  return obj;
  122|    706|}

_ZN6google4grpc11transcoding13MessageReaderC2EPNS1_21TranscoderInputStreamE:
   35|    612|      finished_(false) {}
_ZN6google4grpc11transcoding13MessageReader11NextMessageEv:
   80|   665k|std::unique_ptr<pbio::ZeroCopyInputStream> MessageReader::NextMessage() {
   81|   665k|  if (Finished()) {
  ------------------
  |  Branch (81:7): [True: 0, False: 665k]
  ------------------
   82|       |    // The stream has ended
   83|      0|    return nullptr;
   84|      0|  }
   85|       |
   86|       |  // Check if we have the current message size. If not try to read it.
   87|   665k|  if (!have_current_message_size_) {
  ------------------
  |  Branch (87:7): [True: 155k, False: 509k]
  ------------------
   88|   155k|    if (in_->BytesAvailable() <
  ------------------
  |  Branch (88:9): [True: 100k, False: 54.7k]
  ------------------
   89|   155k|        static_cast<pb::int64>(kGrpcDelimiterByteSize)) {
   90|       |      // We don't have 5 bytes available to read the length of the message.
   91|       |      // Find out whether the stream is finished and return false.
   92|   100k|      finished_ = in_->Finished();
   93|   100k|      if (finished_ && in_->BytesAvailable() != 0) {
  ------------------
  |  Branch (93:11): [True: 0, False: 100k]
  |  Branch (93:24): [True: 0, False: 0]
  ------------------
   94|      0|        status_ = absl::Status(
   95|      0|            absl::StatusCode::kInternal,
   96|      0|            "Incomplete gRPC frame header received");
   97|      0|      }
   98|   100k|      return nullptr;
   99|   100k|    }
  100|       |
  101|       |    // Try to read the delimiter.
  102|  54.7k|    memset(delimiter_, 0, kGrpcDelimiterByteSize);
  103|  54.7k|    if (!ReadStream(in_, delimiter_, kGrpcDelimiterByteSize)) {
  ------------------
  |  Branch (103:9): [True: 0, False: 54.7k]
  ------------------
  104|      0|      finished_ = true;
  105|      0|      return nullptr;
  106|      0|    }
  107|       |
  108|  54.7k|    if (delimiter_[0] != 0) {
  ------------------
  |  Branch (108:9): [True: 114, False: 54.6k]
  ------------------
  109|    114|      status_ = absl::Status(
  110|    114|          absl::StatusCode::kInternal,
  111|    114|          "Unsupported gRPC frame flag: " + std::to_string(delimiter_[0]));
  112|    114|      return nullptr;
  113|    114|    }
  114|       |
  115|  54.6k|    current_message_size_ = DelimiterToSize(delimiter_);
  116|  54.6k|    have_current_message_size_ = true;
  117|  54.6k|  }
  118|       |
  119|   564k|  if (in_->BytesAvailable() < static_cast<pb::int64>(current_message_size_)) {
  ------------------
  |  Branch (119:7): [True: 509k, False: 54.3k]
  ------------------
  120|   509k|    if (in_->Finished()) {
  ------------------
  |  Branch (120:9): [True: 0, False: 509k]
  ------------------
  121|      0|      status_ = absl::Status(
  122|      0|          absl::StatusCode::kInternal,
  123|      0|          "Incomplete gRPC frame expected size: " +
  124|      0|              std::to_string(current_message_size_) + " actual size: " +
  125|      0|              std::to_string(in_->BytesAvailable()));
  126|      0|    }
  127|       |    // We don't have a full message
  128|   509k|    return nullptr;
  129|   509k|  }
  130|       |
  131|       |  // Reset the have_current_message_size_ for the next message
  132|  54.3k|  have_current_message_size_ = false;
  133|       |
  134|       |  // We have a message! Use LimitingInputStream to wrap the input stream and
  135|       |  // limit it to current_message_size_ bytes to cover only the current message.
  136|  54.3k|  return std::unique_ptr<pbio::ZeroCopyInputStream>(
  137|  54.3k|      new pbio::LimitingInputStream(in_, current_message_size_));
  138|   564k|}
_ZN6google4grpc11transcoding13MessageReader23NextMessageAndGrpcFrameEv:
  140|   665k|MessageAndGrpcFrame MessageReader::NextMessageAndGrpcFrame() {
  141|   665k|  MessageAndGrpcFrame out;
  142|   665k|  out.message = NextMessage();
  143|   665k|  memcpy(out.grpc_frame, delimiter_, kGrpcDelimiterByteSize);
  144|   665k|  out.message_size = current_message_size_;
  145|   665k|  return out;
  146|   665k|}
message_reader.cc:_ZN6google4grpc11transcoding12_GLOBAL__N_110ReadStreamEPNS_8protobuf2io19ZeroCopyInputStreamEPhi:
   42|  54.7k|                int size) {
   43|  54.7k|  int size_in = 0;
   44|  54.7k|  const void* data_in = nullptr;
   45|       |  // While we have bytes to read
   46|   271k|  while (size > 0) {
  ------------------
  |  Branch (46:10): [True: 216k, False: 54.7k]
  ------------------
   47|   216k|    if (!stream->Next(&data_in, &size_in)) {
  ------------------
  |  Branch (47:9): [True: 0, False: 216k]
  ------------------
   48|      0|      return false;
   49|      0|    }
   50|   216k|    int to_copy = std::min(size, size_in);
   51|   216k|    memcpy(buffer, data_in, to_copy);
   52|       |    // Advance buffer and subtract the size to reflect the number of bytes left
   53|   216k|    buffer += to_copy;
   54|   216k|    size -= to_copy;
   55|       |    // Keep track of uncopied bytes
   56|   216k|    size_in -= to_copy;
   57|   216k|  }
   58|       |  // Return the uncopied bytes
   59|  54.7k|  stream->BackUp(size_in);
   60|  54.7k|  return true;
   61|  54.7k|}
message_reader.cc:_ZN6google4grpc11transcoding12_GLOBAL__N_115DelimiterToSizeEPKh:
   65|  54.6k|uint32_t DelimiterToSize(const unsigned char* delimiter) {
   66|  54.6k|  unsigned size = 0;
   67|       |  // Bytes 1-4 are big-endian 32-bit message size
   68|  54.6k|  size = size | static_cast<unsigned>(delimiter[1]);
   69|  54.6k|  size <<= 8;
   70|  54.6k|  size = size | static_cast<unsigned>(delimiter[2]);
   71|  54.6k|  size <<= 8;
   72|  54.6k|  size = size | static_cast<unsigned>(delimiter[3]);
   73|  54.6k|  size <<= 8;
   74|  54.6k|  size = size | static_cast<unsigned>(delimiter[4]);
   75|  54.6k|  return size;
   76|  54.6k|}

LLVMFuzzerTestOneInput:
   16|    612|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   17|    612|  FuzzedDataProvider provider(data, size);
   18|       |
   19|    612|  TestZeroCopyInputStream input_stream;
   20|    612|  MessageReader reader(&input_stream);
   21|       |
   22|   665k|  while (provider.remaining_bytes() > 0) {
  ------------------
  |  Branch (22:10): [True: 665k, False: 498]
  ------------------
   23|       |    // Add a few chucks of data to the input stream.
   24|  1.89M|    for (int i = 0; i < provider.ConsumeIntegralInRange(0, 5); i++) {
  ------------------
  |  Branch (24:21): [True: 1.22M, False: 665k]
  ------------------
   25|  1.22M|      input_stream.AddChunk(provider.ConsumeRandomLengthString(100));
   26|  1.22M|    }
   27|       |
   28|       |    // Run the message reader to get the next message.
   29|   665k|    (void)reader.NextMessageAndGrpcFrame();
   30|       |
   31|       |    // Handle end of input or error due to malformed bytes.
   32|   665k|    if (reader.Finished()) {
  ------------------
  |  Branch (32:9): [True: 114, False: 665k]
  ------------------
   33|    114|      return 0;
   34|    114|    }
   35|   665k|  }
   36|       |
   37|    498|  return 0;
   38|    612|}

_ZN6google4grpc11transcoding7testing23TestZeroCopyInputStreamC1Ev:
   43|    612|    : finished_(false), position_(0) {}
_ZN6google4grpc11transcoding7testing23TestZeroCopyInputStream8AddChunkENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
   45|  1.22M|void TestZeroCopyInputStream::AddChunk(std::string chunk) {
   46|       |  // Some of our tests generate 0-sized chunks. Let's not add them to the flow
   47|       |  // here because the tests explicitly handle 'out of input' and 'there is now
   48|       |  // new input' situations explicitly and empty chunks in the input would
   49|       |  // interfere with the test driver logic.
   50|  1.22M|  if (!chunk.empty()) {
  ------------------
  |  Branch (50:7): [True: 1.21M, False: 9.62k]
  ------------------
   51|  1.21M|    chunks_.emplace_back(std::move(chunk));
   52|  1.21M|  }
   53|  1.22M|}
_ZN6google4grpc11transcoding7testing23TestZeroCopyInputStream4NextEPPKvPi:
   55|   216k|bool TestZeroCopyInputStream::Next(const void** data, int* size) {
   56|   216k|  if (position_ < static_cast<int>(current_.size())) {
  ------------------
  |  Branch (56:7): [True: 14.6k, False: 202k]
  ------------------
   57|       |    // Still have some data in the current buffer
   58|  14.6k|    *data = current_.data() + position_;
   59|  14.6k|    *size = current_.size() - position_;
   60|  14.6k|    position_ = current_.size();
   61|  14.6k|    return true;
   62|   202k|  } else if (!chunks_.empty()) {
  ------------------
  |  Branch (62:14): [True: 202k, False: 0]
  ------------------
   63|       |    // Return the next buffer
   64|   202k|    current_ = std::move(chunks_.front());
   65|   202k|    chunks_.pop_front();
   66|   202k|    *data = current_.data();
   67|   202k|    *size = current_.size();
   68|   202k|    position_ = current_.size();
   69|   202k|    return true;
   70|   202k|  } else {
   71|      0|    *size = 0;
   72|      0|    return !finished_;
   73|      0|  }
   74|   216k|}
_ZN6google4grpc11transcoding7testing23TestZeroCopyInputStream6BackUpEi:
   76|  54.7k|void TestZeroCopyInputStream::BackUp(int count) {
   77|   109k|  EXPECT_TRUE(count <= position_) << "Out of bounds while trying to back up "
   78|   109k|                                     "the input stream. position: "
   79|   109k|                                  << position_ << " count: " << count
   80|   109k|                                  << std::endl;
   81|  54.7k|  position_ -= count;
   82|  54.7k|}
_ZNK6google4grpc11transcoding7testing23TestZeroCopyInputStream14BytesAvailableEv:
   84|   719k|int64_t TestZeroCopyInputStream::BytesAvailable() const {
   85|   719k|  auto total = current_.size() - position_;
   86|  4.63G|  for (auto chunk : chunks_) {
  ------------------
  |  Branch (86:19): [True: 4.63G, False: 719k]
  ------------------
   87|  4.63G|    total += chunk.size();
   88|  4.63G|  }
   89|   719k|  return total;
   90|   719k|}

_ZNK6google4grpc11transcoding7testing23TestZeroCopyInputStream8FinishedEv:
   48|   610k|  bool Finished() const { return finished_; }
_ZNK6google4grpc11transcoding7testing23TestZeroCopyInputStream9ByteCountEv:
   54|  54.3k|  int64_t ByteCount() const { return 0; }  // Not implemented