_ZN6google8protobuf5Arena21CreateMessageInternalIN8asn1_pdu3PDUEEEPT_PS1_:
  551|  10.4k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  10.4k|    static_assert(
  553|  10.4k|        InternalHelper<T>::is_arena_constructable::value,
  554|  10.4k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  10.4k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 10.4k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  10.4k|      return InternalHelper<T>::New();
  559|  10.4k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  10.4k|  }
_ZN6google8protobuf5Arena14InternalHelperIN8asn1_pdu3PDUEE3NewEv:
  487|  10.4k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  10.4k|      return new T(nullptr);
  489|  10.4k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN8asn1_pdu10IdentifierEEEPT_PS1_:
  551|  12.7k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  12.7k|    static_assert(
  553|  12.7k|        InternalHelper<T>::is_arena_constructable::value,
  554|  12.7k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  12.7k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 12.7k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  12.7k|      return InternalHelper<T>::New();
  559|  12.7k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  12.7k|  }
_ZN6google8protobuf5Arena14InternalHelperIN8asn1_pdu10IdentifierEE3NewEv:
  487|  12.7k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  12.7k|      return new T(nullptr);
  489|  12.7k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN8asn1_pdu9TagNumberEEEPT_PS1_:
  551|  12.4k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  12.4k|    static_assert(
  553|  12.4k|        InternalHelper<T>::is_arena_constructable::value,
  554|  12.4k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  12.4k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 12.4k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  12.4k|      return InternalHelper<T>::New();
  559|  12.4k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  12.4k|  }
_ZN6google8protobuf5Arena14InternalHelperIN8asn1_pdu9TagNumberEE3NewEv:
  487|  12.4k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  12.4k|      return new T(nullptr);
  489|  12.4k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN8asn1_pdu6LengthEEEPT_PS1_:
  551|  12.4k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  12.4k|    static_assert(
  553|  12.4k|        InternalHelper<T>::is_arena_constructable::value,
  554|  12.4k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  12.4k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 12.4k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  12.4k|      return InternalHelper<T>::New();
  559|  12.4k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  12.4k|  }
_ZN6google8protobuf5Arena14InternalHelperIN8asn1_pdu6LengthEE3NewEv:
  487|  12.4k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  12.4k|      return new T(nullptr);
  489|  12.4k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN8asn1_pdu12ValueElementEEEPT_PS1_:
  551|  15.3k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  15.3k|    static_assert(
  553|  15.3k|        InternalHelper<T>::is_arena_constructable::value,
  554|  15.3k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  15.3k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 15.3k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  15.3k|      return InternalHelper<T>::New();
  559|  15.3k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  15.3k|  }
_ZN6google8protobuf5Arena14InternalHelperIN8asn1_pdu12ValueElementEE3NewEv:
  487|  15.3k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  15.3k|      return new T(nullptr);
  489|  15.3k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN8asn1_pdu5ValueEEEPT_PS1_:
  551|  12.5k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  12.5k|    static_assert(
  553|  12.5k|        InternalHelper<T>::is_arena_constructable::value,
  554|  12.5k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  12.5k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 12.5k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  12.5k|      return InternalHelper<T>::New();
  559|  12.5k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  12.5k|  }
_ZN6google8protobuf5Arena14InternalHelperIN8asn1_pdu5ValueEE3NewEv:
  487|  12.5k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  12.5k|      return new T(nullptr);
  489|  12.5k|    }

_ZN6google8protobuf8internal15TaggedStringPtrC2EPNS1_21ExplicitlyConstructedINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELm8EEE:
  133|  15.3k|      : ptr_(ptr) {}
_ZNK6google8protobuf8internal15TaggedStringPtr3GetEv:
  189|  10.0k|  inline std::string* Get() const {
  190|  10.0k|    return reinterpret_cast<std::string*>(as_int() & ~kMask);
  191|  10.0k|  }
_ZNK6google8protobuf8internal15TaggedStringPtr6as_intEv:
  210|  10.0k|  uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
_ZNK6google8protobuf8internal14ArenaStringPtr3GetEv:
  299|  8.29k|  PROTOBUF_NDEBUG_INLINE const std::string& Get() const {
  300|       |    // Unconditionally mask away the tag.
  301|  8.29k|    return *tagged_ptr_.Get();
  302|  8.29k|  }
_ZN6google8protobuf8internal14ArenaStringPtr11InitDefaultEv:
  395|  15.3k|inline void ArenaStringPtr::InitDefault() {
  396|  15.3k|  tagged_ptr_ = TaggedStringPtr(&fixed_address_empty_string);
  397|  15.3k|}
_ZN6google8protobuf8internal14ArenaStringPtr22ClearNonDefaultToEmptyEv:
  475|  1.77k|inline void ArenaStringPtr::ClearNonDefaultToEmpty() {
  476|       |  // Unconditionally mask away the tag.
  477|  1.77k|  tagged_ptr_.Get()->clear();
  478|  1.77k|}

_ZN6google8protobuf8internal10CachedSizeC2Ev:
  198|  78.2k|  constexpr CachedSize() noexcept : atom_(Scalar{}) {}

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

_ZN6google8protobuf7MessageC2EPNS0_5ArenaE:
  414|  78.2k|  inline explicit Message(Arena* arena) : MessageLite(arena) {}

_ZN6google8protobuf11MessageLiteC2EPNS0_5ArenaE:
  468|  78.2k|  inline explicit MessageLite(Arena* arena) : _internal_metadata_(arena) {}
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN8asn1_pdu3PDUEEEPT_PNS0_5ArenaE:
  464|  10.4k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  10.4k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  10.4k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN8asn1_pdu10IdentifierEEEPT_PNS0_5ArenaE:
  464|  12.7k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  12.7k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  12.7k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN8asn1_pdu9TagNumberEEEPT_PNS0_5ArenaE:
  464|  12.4k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  12.4k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  12.4k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN8asn1_pdu6LengthEEEPT_PNS0_5ArenaE:
  464|  12.4k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  12.4k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  12.4k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN8asn1_pdu12ValueElementEEEPT_PNS0_5ArenaE:
  464|  15.3k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  15.3k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  15.3k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN8asn1_pdu5ValueEEEPT_PNS0_5ArenaE:
  464|  12.5k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  12.5k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  12.5k|  }
_ZN6google8protobuf11MessageLiteD2Ev:
  175|  78.2k|  virtual ~MessageLite() = default;

_ZN6google8protobuf8internal16InternalMetadataC2EPNS0_5ArenaE:
   70|  78.2k|  explicit InternalMetadata(Arena* arena) {
   71|  78.2k|    ptr_ = reinterpret_cast<intptr_t>(arena);
   72|  78.2k|  }
_ZNK6google8protobuf8internal16InternalMetadata19have_unknown_fieldsEv:
  106|   128k|  PROTOBUF_NDEBUG_INLINE bool have_unknown_fields() const {
  107|   128k|    return HasUnknownFieldsTag();
  108|   128k|  }
_ZNK6google8protobuf8internal16InternalMetadata19HasUnknownFieldsTagEv:
  173|   128k|  PROTOBUF_ALWAYS_INLINE bool HasUnknownFieldsTag() const {
  174|   128k|    return ptr_ & kUnknownFieldsTagMask;
  175|   128k|  }
_ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS0_5ArenaEEEPT_v:
  178|  78.2k|  U* PtrValue() const {
  179|  78.2k|    return reinterpret_cast<U*>(ptr_ & kPtrValueMask);
  180|  78.2k|  }
_ZN6google8protobuf8internal16InternalMetadata9MergeFromINS0_15UnknownFieldSetEEEvRKS2_:
  151|  9.57k|  PROTOBUF_NDEBUG_INLINE void MergeFrom(const InternalMetadata& other) {
  152|  9.57k|    if (other.have_unknown_fields()) {
  ------------------
  |  Branch (152:9): [True: 0, False: 9.57k]
  ------------------
  153|      0|      DoMergeFrom<T>(other.unknown_fields<T>(nullptr));
  154|      0|    }
  155|  9.57k|  }
_ZN6google8protobuf8internal16InternalMetadata17DeleteReturnArenaINS0_15UnknownFieldSetEEEPNS0_5ArenaEv:
   90|  78.2k|  Arena* DeleteReturnArena() {
   91|  78.2k|    if (have_unknown_fields()) {
  ------------------
  |  Branch (91:9): [True: 0, False: 78.2k]
  ------------------
   92|      0|      return DeleteOutOfLineHelper<T>();
   93|  78.2k|    } else {
   94|  78.2k|      return PtrValue<Arena>();
   95|  78.2k|    }
   96|  78.2k|  }
_ZN6google8protobuf8internal16InternalMetadata5ClearINS0_15UnknownFieldSetEEEvv:
  158|  40.6k|  PROTOBUF_NDEBUG_INLINE void Clear() {
  159|  40.6k|    if (have_unknown_fields()) {
  ------------------
  |  Branch (159:9): [True: 0, False: 40.6k]
  ------------------
  160|      0|      DoClear<T>();
  161|      0|    }
  162|  40.6k|  }

_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2EPNS0_5ArenaE:
  169|  12.5k|      : arena_(arena), current_size_(0), total_size_(0), rep_(nullptr) {}
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseD2Ev:
  174|  12.5k|  ~RepeatedPtrFieldBase() {
  175|       |#ifndef NDEBUG
  176|       |    // Try to trigger segfault / asan failure in non-opt builds. If arena_
  177|       |    // lifetime has ended before the destructor.
  178|       |    if (arena_) (void)arena_->SpaceAllocated();
  179|       |#endif
  180|  12.5k|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv:
  183|  8.48k|  int size() const { return current_size_; }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase12NeedsDestroyEv:
  261|  12.5k|  bool NeedsDestroy() const { return rep_ != nullptr && arena_ == nullptr; }
  ------------------
  |  Branch (261:38): [True: 4.09k, False: 8.41k]
  |  Branch (261:57): [True: 4.09k, False: 0]
  ------------------
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8raw_dataEv:
  372|  16.9k|  void* const* raw_data() const { return rep_ ? rep_->elements : nullptr; }
  ------------------
  |  Branch (372:42): [True: 6.14k, False: 10.8k]
  ------------------
_ZN6google8protobuf8internal20RepeatedPtrFieldBase19ExchangeCurrentSizeEi:
  668|  1.02k|  inline int ExchangeCurrentSize(int new_size) {
  669|  1.02k|    int prev_size = current_size_;
  670|  1.02k|    current_size_ = new_size;
  671|  1.02k|    return prev_size;
  672|  1.02k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN8asn1_pdu12ValueElementEE4sizeEv:
 1329|  8.48k|inline int RepeatedPtrField<Element>::size() const {
 1330|  8.48k|  return RepeatedPtrFieldBase::size();
 1331|  8.48k|}
_ZN6google8protobuf16RepeatedPtrFieldIN8asn1_pdu12ValueElementEE5ClearEv:
 1484|  6.29k|inline void RepeatedPtrField<Element>::Clear() {
 1485|  6.29k|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 1486|  6.29k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN8asn1_pdu12ValueElementEE11TypeHandlerEEEvv:
  283|  6.29k|  void Clear() {
  284|  6.29k|    const int n = current_size_;
  285|  6.29k|    ABSL_DCHECK_GE(n, 0);
  ------------------
  |  |   78|  6.29k|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|  6.29k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  6.29k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  6.29k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  286|  6.29k|    if (n > 0) {
  ------------------
  |  Branch (286:9): [True: 1.02k, False: 5.27k]
  ------------------
  287|  1.02k|      ClearNonEmpty<TypeHandler>();
  288|  1.02k|    }
  289|  6.29k|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase13ClearNonEmptyINS0_16RepeatedPtrFieldIN8asn1_pdu12ValueElementEE11TypeHandlerEEEvv:
  696|  1.02k|  PROTOBUF_NOINLINE void ClearNonEmpty() {
  697|  1.02k|    const int n = current_size_;
  698|  1.02k|    void* const* elements = rep_->elements;
  699|  1.02k|    int i = 0;
  700|  1.02k|    ABSL_DCHECK_GT(
  ------------------
  |  |   80|  1.02k|  ABSL_DCHECK_GT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   96|  1.02k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  1.02k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  1.02k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  701|  1.02k|        n,
  702|  1.02k|        0);  // do/while loop to avoid initial test because we know n > 0
  703|  5.76k|    do {
  704|  5.76k|      TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
  705|  5.76k|    } while (i < n);
  ------------------
  |  Branch (705:14): [True: 4.74k, False: 1.02k]
  ------------------
  706|  1.02k|    ExchangeCurrentSize(0);
  707|  1.02k|  }
_ZN6google8protobuf8internal18GenericTypeHandlerIN8asn1_pdu12ValueElementEE5ClearEPS4_:
  819|  5.76k|  static inline void Clear(GenericType* value) { value->Clear(); }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldIN8asn1_pdu12ValueElementEE11TypeHandlerEEEPNT_4TypeEPv:
  685|  5.76k|  static inline typename TypeHandler::Type* cast(void* element) {
  686|  5.76k|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  687|  5.76k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN8asn1_pdu12ValueElementEEC2EPNS0_5ArenaE:
 1246|  12.5k|    : RepeatedPtrFieldBase(arena) {
 1247|  12.5k|  StaticValidityCheck();
 1248|  12.5k|}
_ZN6google8protobuf16RepeatedPtrFieldIN8asn1_pdu12ValueElementEE19StaticValidityCheckEv:
  913|  25.0k|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  914|  25.0k|    static_assert(
  915|  25.0k|        absl::disjunction<
  916|  25.0k|            internal::is_supported_string_type<Element>,
  917|  25.0k|            internal::is_supported_message_type<Element>>::value,
  918|  25.0k|        "We only support string and Message types in RepeatedPtrField.");
  919|  25.0k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN8asn1_pdu12ValueElementEED2Ev:
 1266|  12.5k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1267|  12.5k|  StaticValidityCheck();
 1268|       |#ifdef __cpp_if_constexpr
 1269|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1270|       |#else
 1271|  12.5k|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1271:7): [Folded - Ignored]
  ------------------
 1272|  12.5k|#endif
 1273|  12.5k|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1273:9): [True: 4.09k, False: 8.41k]
  ------------------
 1274|  12.5k|  } else {
 1275|      0|    Destroy<TypeHandler>();
 1276|      0|  }
 1277|  12.5k|}
_ZNK6google8protobuf16RepeatedPtrFieldIN8asn1_pdu12ValueElementEE5beginEv:
 1845|  8.48k|RepeatedPtrField<Element>::begin() const {
 1846|  8.48k|  return iterator(raw_data());
 1847|  8.48k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN8asn1_pdu12ValueElementEEC2EPKPv:
 1643|  16.9k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN8asn1_pdu12ValueElementEEC2IS4_LPv0EEERKNS2_IT_EE:
 1651|  16.9k|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN8asn1_pdu12ValueElementEE3endEv:
 1860|  8.48k|RepeatedPtrField<Element>::end() const {
 1861|  8.48k|  return iterator(raw_data() + size());
 1862|  8.48k|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKN8asn1_pdu12ValueElementEEES8_:
 1673|  18.0k|  friend bool operator!=(const iterator& x, const iterator& y) {
 1674|  18.0k|    return x.it_ != y.it_;
 1675|  18.0k|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN8asn1_pdu12ValueElementEEppEv:
 1658|  9.57k|  iterator& operator++() {
 1659|  9.57k|    ++it_;
 1660|  9.57k|    return *this;
 1661|  9.57k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN8asn1_pdu12ValueElementEEdeEv:
 1654|  9.57k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZN6google8protobuf16RepeatedPtrFieldIN8asn1_pdu12ValueElementEE9MergeFromERKS4_:
 1490|  2.27k|    const RepeatedPtrField& other) {
 1491|  2.27k|  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
 1492|  2.27k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase9MergeFromINS0_16RepeatedPtrFieldIN8asn1_pdu12ValueElementEE11TypeHandlerEEEvRKS2_:
  292|  2.27k|  void MergeFrom(const RepeatedPtrFieldBase& other) {
  293|       |    // To avoid unnecessary code duplication and reduce binary size, we use a
  294|       |    // layered approach to implementing MergeFrom(). The toplevel method is
  295|       |    // templated, so we get a small thunk per concrete message type in the
  296|       |    // binary. This calls a shared implementation with most of the logic,
  297|       |    // passing a function pointer to another type-specific piece of code that
  298|       |    // calls the object-allocate and merge handlers.
  299|  2.27k|    ABSL_DCHECK_NE(&other, this);
  ------------------
  |  |   72|  2.27k|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|  2.27k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  2.27k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  2.27k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  300|  2.27k|    if (other.current_size_ == 0) return;
  ------------------
  |  Branch (300:9): [True: 2.27k, False: 0]
  ------------------
  301|      0|    MergeFromInternal(other,
  302|      0|                      &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
  303|      0|  }

_ZN8asn1_pdu12ASN1PDUToDER20EncodeOverrideLengthERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEm:
   30|  1.74k|                                        size_t len_pos) {
   31|  1.74k|  der_.insert(der_.begin() + len_pos, raw_len.begin(), raw_len.end());
   32|  1.74k|}
_ZN8asn1_pdu12ASN1PDUToDER22EncodeIndefiniteLengthEm:
   34|    677|void ASN1PDUToDER::EncodeIndefiniteLength(size_t len_pos) {
   35|    677|  der_.insert(der_.begin() + len_pos, 0x80);
   36|       |  // The PDU's value is from |len_pos| to the end of |der_|, so just add an
   37|       |  // EOC marker to the end.
   38|    677|  der_.push_back(0x00);
   39|    677|  der_.push_back(0x00);
   40|    677|}
_ZN8asn1_pdu12ASN1PDUToDER20EncodeDefiniteLengthEmm:
   42|  6.06k|void ASN1PDUToDER::EncodeDefiniteLength(size_t actual_len, size_t len_pos) {
   43|  6.06k|  InsertVariableIntBase256(actual_len, len_pos, der_);
   44|       |  // X.690 (2015), 8.1.3.3: The long-form is used when the length is
   45|       |  // larger than 127.
   46|       |  // Note: |len_num_bytes| is not checked here, because it will equal
   47|       |  // 1 for values [128..255], but those require the long-form length.
   48|  6.06k|  if (actual_len > 127) {
  ------------------
  |  Branch (48:7): [True: 1.29k, False: 4.77k]
  ------------------
   49|       |    // See X.690 (2015) 8.1.3.5.
   50|       |    // Long-form length is encoded as a byte with the high-bit set to indicate
   51|       |    // the long-form, while the remaining bits indicate how many bytes are used
   52|       |    // to encode the length.
   53|  1.29k|    size_t len_num_bytes = GetVariableIntLen(actual_len, 256);
   54|  1.29k|    der_.insert(der_.begin() + len_pos, (0x80 | len_num_bytes));
   55|  1.29k|  }
   56|  6.06k|}
_ZN8asn1_pdu12ASN1PDUToDER12EncodeLengthERKNS_6LengthEmm:
   60|  8.48k|                                size_t len_pos) {
   61|  8.48k|  if (len.has_length_override()) {
  ------------------
  |  Branch (61:7): [True: 1.74k, False: 6.74k]
  ------------------
   62|  1.74k|    EncodeOverrideLength(len.length_override(), len_pos);
   63|  6.74k|  } else if (len.has_indefinite_form() && len.indefinite_form()) {
  ------------------
  |  Branch (63:14): [True: 874, False: 5.86k]
  |  Branch (63:43): [True: 677, False: 197]
  ------------------
   64|    677|    EncodeIndefiniteLength(len_pos);
   65|  6.06k|  } else {
   66|  6.06k|    EncodeDefiniteLength(actual_len, len_pos);
   67|  6.06k|  }
   68|  8.48k|}
_ZN8asn1_pdu12ASN1PDUToDER11EncodeValueERKNS_5ValueE:
   70|  8.48k|void ASN1PDUToDER::EncodeValue(const Value& val) {
   71|  9.57k|  for (const auto& val_ele : val.val_array()) {
  ------------------
  |  Branch (71:28): [True: 9.57k, False: 8.48k]
  ------------------
   72|  9.57k|    if (recursion_exceeded_) {
  ------------------
  |  Branch (72:9): [True: 0, False: 9.57k]
  ------------------
   73|       |      // If the message exceeds the recursion limit, abort processing the
   74|       |      // protobuf in order to limit uninteresting work.
   75|      0|      return;
   76|      0|    }
   77|  9.57k|    if (val_ele.has_pdu()) {
  ------------------
  |  Branch (77:9): [True: 6.29k, False: 3.27k]
  ------------------
   78|  6.29k|      EncodePDU(val_ele.pdu());
   79|  6.29k|    } else {
   80|  3.27k|      der_.insert(der_.end(), val_ele.val_bits().begin(),
   81|  3.27k|                  val_ele.val_bits().end());
   82|  3.27k|    }
   83|  9.57k|  }
   84|  8.48k|}
_ZN8asn1_pdu12ASN1PDUToDER23EncodeHighTagNumberFormEhhj:
   88|  1.40k|                                           uint32_t tag_num) {
   89|       |  // High-tag-number form requires the lower 5 bits of the identifier to be set
   90|       |  // to 1 (X.690 (2015), 8.1.2.4.1).
   91|  1.40k|  der_.push_back(id_class | encoding | 0x1F);
   92|       |  // The high-tag-number form base 128 encodes |tag_num| (X.690 (2015), 8.1.2).
   93|  1.40k|  InsertVariableIntBase128(tag_num, der_.size(), der_);
   94|  1.40k|}
_ZN8asn1_pdu12ASN1PDUToDER16EncodeIdentifierERKNS_10IdentifierE:
   96|  8.48k|void ASN1PDUToDER::EncodeIdentifier(const Identifier& id) {
   97|       |  // The class comprises the 7th and 8th bit of the identifier (X.690
   98|       |  // (2015), 8.1.2).
   99|  8.48k|  uint8_t id_class = static_cast<uint8_t>(id.id_class()) << 6;
  100|       |  // The encoding comprises the 6th bit of the identifier (X.690 (2015), 8.1.2).
  101|  8.48k|  uint8_t encoding = static_cast<uint8_t>(id.encoding()) << 5;
  102|       |
  103|  8.48k|  uint32_t tag_num = id.tag_num().has_high_tag_num()
  ------------------
  |  Branch (103:22): [True: 1.53k, False: 6.95k]
  ------------------
  104|  8.48k|                         ? id.tag_num().high_tag_num()
  105|  8.48k|                         : id.tag_num().low_tag_num();
  106|       |  // When the tag number is greater than or equal to 31, encode with a single
  107|       |  // byte; otherwise, use the high-tag-number form (X.690 (2015), 8.1.2).
  108|  8.48k|  if (tag_num >= 31) {
  ------------------
  |  Branch (108:7): [True: 1.40k, False: 7.08k]
  ------------------
  109|  1.40k|    EncodeHighTagNumberForm(id_class, encoding, tag_num);
  110|  7.08k|  } else {
  111|  7.08k|    der_.push_back(static_cast<uint8_t>(id_class | encoding | tag_num));
  112|  7.08k|  }
  113|  8.48k|}
_ZN8asn1_pdu12ASN1PDUToDER9EncodePDUERKNS_3PDUE:
  115|  8.48k|void ASN1PDUToDER::EncodePDU(const PDU& pdu) {
  116|       |  // Artifically limit the stack depth to avoid stack overflow.
  117|  8.48k|  if (depth_ > kRecursionLimit) {
  ------------------
  |  Branch (117:7): [True: 0, False: 8.48k]
  ------------------
  118|      0|    recursion_exceeded_ = true;
  119|      0|    return;
  120|      0|  }
  121|  8.48k|  ++depth_;
  122|  8.48k|  EncodeIdentifier(pdu.id());
  123|  8.48k|  size_t len_pos = der_.size();
  124|  8.48k|  EncodeValue(pdu.val());
  125|  8.48k|  EncodeLength(pdu.len(), der_.size() - len_pos, len_pos);
  126|  8.48k|  --depth_;
  127|  8.48k|}
_ZN8asn1_pdu12ASN1PDUToDER8PDUToDERERKNS_3PDUE:
  129|  2.18k|std::vector<uint8_t> ASN1PDUToDER::PDUToDER(const PDU& pdu) {
  130|       |  // Reset the previous state.
  131|  2.18k|  der_.clear();
  132|  2.18k|  depth_ = 0;
  133|  2.18k|  recursion_exceeded_ = false;
  134|       |
  135|  2.18k|  EncodePDU(pdu);
  136|  2.18k|  if (recursion_exceeded_) {
  ------------------
  |  Branch (136:7): [True: 0, False: 2.18k]
  ------------------
  137|      0|    der_.clear();
  138|      0|  }
  139|  2.18k|  return der_;
  140|  2.18k|}

CBS_asn1_ber_to_der:
  193|  2.18k|int CBS_asn1_ber_to_der(CBS *in, CBS *out, uint8_t **out_storage) {
  194|  2.18k|  CBB cbb;
  195|       |
  196|       |  // First, do a quick walk to find any indefinite-length elements. Most of the
  197|       |  // time we hope that there aren't any and thus we can quickly return.
  198|  2.18k|  int conversion_needed;
  199|  2.18k|  if (!cbs_find_ber(in, &conversion_needed, 0)) {
  ------------------
  |  Branch (199:7): [True: 804, False: 1.38k]
  ------------------
  200|    804|    return 0;
  201|    804|  }
  202|       |
  203|  1.38k|  if (!conversion_needed) {
  ------------------
  |  Branch (203:7): [True: 722, False: 660]
  ------------------
  204|    722|    if (!CBS_get_any_asn1_element(in, out, NULL, NULL)) {
  ------------------
  |  Branch (204:9): [True: 0, False: 722]
  ------------------
  205|      0|      return 0;
  206|      0|    }
  207|    722|    *out_storage = NULL;
  208|    722|    return 1;
  209|    722|  }
  210|       |
  211|    660|  size_t len;
  212|    660|  if (!CBB_init(&cbb, CBS_len(in)) ||
  ------------------
  |  Branch (212:7): [True: 0, False: 660]
  ------------------
  213|    660|      !cbs_convert_ber(in, &cbb, 0, 0, 0) ||
  ------------------
  |  Branch (213:7): [True: 387, False: 273]
  ------------------
  214|    660|      !CBB_finish(&cbb, out_storage, &len)) {
  ------------------
  |  Branch (214:7): [True: 0, False: 273]
  ------------------
  215|    387|    CBB_cleanup(&cbb);
  216|    387|    return 0;
  217|    387|  }
  218|       |
  219|    273|  CBS_init(out, *out_storage, len);
  220|    273|  return 1;
  221|    660|}
ber.c:cbs_find_ber:
   58|  5.43k|static int cbs_find_ber(const CBS *orig_in, int *ber_found, uint32_t depth) {
   59|  5.43k|  CBS in;
   60|       |
   61|  5.43k|  if (depth > kMaxDepth) {
  ------------------
  |  Branch (61:7): [True: 0, False: 5.43k]
  ------------------
   62|      0|    return 0;
   63|      0|  }
   64|       |
   65|  5.43k|  CBS_init(&in, CBS_data(orig_in), CBS_len(orig_in));
   66|  5.43k|  *ber_found = 0;
   67|       |
   68|  10.2k|  while (CBS_len(&in) > 0) {
  ------------------
  |  Branch (68:10): [True: 7.00k, False: 3.27k]
  ------------------
   69|  7.00k|    CBS contents;
   70|  7.00k|    CBS_ASN1_TAG tag;
   71|  7.00k|    size_t header_len;
   72|  7.00k|    int indefinite;
   73|  7.00k|    if (!CBS_get_any_ber_asn1_element(&in, &contents, &tag, &header_len,
  ------------------
  |  Branch (73:9): [True: 804, False: 6.20k]
  ------------------
   74|  7.00k|                                      ber_found, &indefinite)) {
   75|    804|      return 0;
   76|    804|    }
   77|  6.20k|    if (*ber_found) {
  ------------------
  |  Branch (77:9): [True: 724, False: 5.47k]
  ------------------
   78|    724|      return 1;
   79|    724|    }
   80|  5.47k|    if (tag & CBS_ASN1_CONSTRUCTED) {
  ------------------
  |  |  196|  5.47k|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  ------------------
  |  |  |  |  193|  5.47k|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
  |  Branch (80:9): [True: 3.67k, False: 1.79k]
  ------------------
   81|  3.67k|      if (is_string_type(tag)) {
  ------------------
  |  Branch (81:11): [True: 427, False: 3.25k]
  ------------------
   82|       |        // Constructed strings are only legal in BER and require conversion.
   83|    427|        *ber_found = 1;
   84|    427|        return 1;
   85|    427|      }
   86|  3.25k|      if (!CBS_skip(&contents, header_len) ||
  ------------------
  |  Branch (86:11): [True: 0, False: 3.25k]
  ------------------
   87|  3.25k|          !cbs_find_ber(&contents, ber_found, depth + 1)) {
  ------------------
  |  Branch (87:11): [True: 207, False: 3.04k]
  ------------------
   88|    207|        return 0;
   89|    207|      }
   90|  3.25k|    }
   91|  5.47k|  }
   92|       |
   93|  3.27k|  return 1;
   94|  5.43k|}
ber.c:cbs_convert_ber:
  114|  44.0k|                           int looking_for_eoc, uint32_t depth) {
  115|  44.0k|  assert(!(string_tag & CBS_ASN1_CONSTRUCTED));
  116|       |
  117|  44.0k|  if (depth > kMaxDepth) {
  ------------------
  |  Branch (117:7): [True: 1, False: 44.0k]
  ------------------
  118|      1|    return 0;
  119|      1|  }
  120|       |
  121|  52.7k|  while (CBS_len(in) > 0) {
  ------------------
  |  Branch (121:10): [True: 49.7k, False: 2.95k]
  ------------------
  122|  49.7k|    if (looking_for_eoc && cbs_get_eoc(in)) {
  ------------------
  |  Branch (122:9): [True: 41.7k, False: 8.05k]
  |  Branch (122:28): [True: 2.03k, False: 39.6k]
  ------------------
  123|  2.03k|      return 1;
  124|  2.03k|    }
  125|       |
  126|  47.7k|    CBS contents;
  127|  47.7k|    CBS_ASN1_TAG tag, child_string_tag = string_tag;
  128|  47.7k|    size_t header_len;
  129|  47.7k|    int indefinite;
  130|  47.7k|    CBB *out_contents, out_contents_storage;
  131|  47.7k|    if (!CBS_get_any_ber_asn1_element(in, &contents, &tag, &header_len,
  ------------------
  |  Branch (131:9): [True: 228, False: 47.4k]
  ------------------
  132|       |                                      /*out_ber_found=*/NULL, &indefinite)) {
  133|    228|      return 0;
  134|    228|    }
  135|       |
  136|  47.4k|    if (string_tag != 0) {
  ------------------
  |  Branch (136:9): [True: 279, False: 47.2k]
  ------------------
  137|       |      // This is part of a constructed string. All elements must match
  138|       |      // |string_tag| up to the constructed bit and get appended to |out|
  139|       |      // without a child element.
  140|    279|      if ((tag & ~CBS_ASN1_CONSTRUCTED) != string_tag) {
  ------------------
  |  |  196|    279|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  ------------------
  |  |  |  |  193|    279|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
  |  Branch (140:11): [True: 54, False: 225]
  ------------------
  141|     54|        return 0;
  142|     54|      }
  143|    225|      out_contents = out;
  144|  47.2k|    } else {
  145|  47.2k|      CBS_ASN1_TAG out_tag = tag;
  146|  47.2k|      if ((tag & CBS_ASN1_CONSTRUCTED) && is_string_type(tag)) {
  ------------------
  |  |  196|  47.2k|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  ------------------
  |  |  |  |  193|  47.2k|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
  |  Branch (146:11): [True: 43.1k, False: 4.04k]
  |  Branch (146:43): [True: 897, False: 42.2k]
  ------------------
  147|       |        // If a constructed string, clear the constructed bit and inform
  148|       |        // children to concatenate bodies.
  149|    897|        out_tag &= ~CBS_ASN1_CONSTRUCTED;
  ------------------
  |  |  196|    897|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  ------------------
  |  |  |  |  193|    897|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
  150|    897|        child_string_tag = out_tag;
  151|    897|      }
  152|  47.2k|      if (!CBB_add_asn1(out, &out_contents_storage, out_tag)) {
  ------------------
  |  Branch (152:11): [True: 0, False: 47.2k]
  ------------------
  153|      0|        return 0;
  154|      0|      }
  155|  47.2k|      out_contents = &out_contents_storage;
  156|  47.2k|    }
  157|       |
  158|  47.4k|    if (indefinite) {
  ------------------
  |  Branch (158:9): [True: 39.1k, False: 8.27k]
  ------------------
  159|  39.1k|      if (!cbs_convert_ber(in, out_contents, child_string_tag,
  ------------------
  |  Branch (159:11): [True: 37.1k, False: 2.03k]
  ------------------
  160|  39.1k|                           /*looking_for_eoc=*/1, depth + 1) ||
  161|  39.1k|          !CBB_flush(out)) {
  ------------------
  |  Branch (161:11): [True: 0, False: 2.03k]
  ------------------
  162|  37.1k|        return 0;
  163|  37.1k|      }
  164|  2.03k|      continue;
  165|  39.1k|    }
  166|       |
  167|  8.27k|    if (!CBS_skip(&contents, header_len)) {
  ------------------
  |  Branch (167:9): [True: 0, False: 8.27k]
  ------------------
  168|      0|      return 0;
  169|      0|    }
  170|       |
  171|  8.27k|    if (tag & CBS_ASN1_CONSTRUCTED) {
  ------------------
  |  |  196|  8.27k|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  ------------------
  |  |  |  |  193|  8.27k|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
  |  Branch (171:9): [True: 4.22k, False: 4.05k]
  ------------------
  172|       |      // Recurse into children.
  173|  4.22k|      if (!cbs_convert_ber(&contents, out_contents, child_string_tag,
  ------------------
  |  Branch (173:11): [True: 1.64k, False: 2.57k]
  ------------------
  174|  4.22k|                           /*looking_for_eoc=*/0, depth + 1)) {
  175|  1.64k|        return 0;
  176|  1.64k|      }
  177|  4.22k|    } else {
  178|       |      // Copy primitive contents as-is.
  179|  4.05k|      if (!CBB_add_bytes(out_contents, CBS_data(&contents),
  ------------------
  |  Branch (179:11): [True: 0, False: 4.05k]
  ------------------
  180|  4.05k|                         CBS_len(&contents))) {
  181|      0|        return 0;
  182|      0|      }
  183|  4.05k|    }
  184|       |
  185|  6.63k|    if (!CBB_flush(out)) {
  ------------------
  |  Branch (185:9): [True: 0, False: 6.63k]
  ------------------
  186|      0|      return 0;
  187|      0|    }
  188|  6.63k|  }
  189|       |
  190|  2.95k|  return looking_for_eoc == 0;
  191|  44.0k|}
ber.c:cbs_get_eoc:
   98|  41.7k|static int cbs_get_eoc(CBS *cbs) {
   99|  41.7k|  if (CBS_len(cbs) >= 2 &&
  ------------------
  |  Branch (99:7): [True: 41.6k, False: 26]
  ------------------
  100|  41.7k|      CBS_data(cbs)[0] == 0 && CBS_data(cbs)[1] == 0) {
  ------------------
  |  Branch (100:7): [True: 2.04k, False: 39.6k]
  |  Branch (100:32): [True: 2.03k, False: 2]
  ------------------
  101|  2.03k|    return CBS_skip(cbs, 2);
  102|  2.03k|  }
  103|  39.6k|  return 0;
  104|  41.7k|}
ber.c:is_string_type:
   31|  46.8k|static int is_string_type(CBS_ASN1_TAG tag) {
   32|       |  // While BER supports constructed BIT STRINGS, OpenSSL misparses them. To
   33|       |  // avoid acting on an ambiguous input, we do not support constructed BIT
   34|       |  // STRINGS. See https://github.com/openssl/openssl/issues/12810.
   35|  46.8k|  switch (tag & ~CBS_ASN1_CONSTRUCTED) {
  ------------------
  |  |  196|  46.8k|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  ------------------
  |  |  |  |  193|  46.8k|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
   36|    210|    case CBS_ASN1_OCTETSTRING:
  ------------------
  |  |  217|    210|#define CBS_ASN1_OCTETSTRING 0x4u
  ------------------
  |  Branch (36:5): [True: 210, False: 46.6k]
  ------------------
   37|    358|    case CBS_ASN1_UTF8STRING:
  ------------------
  |  |  221|    358|#define CBS_ASN1_UTF8STRING 0xcu
  ------------------
  |  Branch (37:5): [True: 148, False: 46.7k]
  ------------------
   38|    420|    case CBS_ASN1_NUMERICSTRING:
  ------------------
  |  |  224|    420|#define CBS_ASN1_NUMERICSTRING 0x12u
  ------------------
  |  Branch (38:5): [True: 62, False: 46.7k]
  ------------------
   39|    757|    case CBS_ASN1_PRINTABLESTRING:
  ------------------
  |  |  225|    757|#define CBS_ASN1_PRINTABLESTRING 0x13u
  ------------------
  |  Branch (39:5): [True: 337, False: 46.5k]
  ------------------
   40|    814|    case CBS_ASN1_T61STRING:
  ------------------
  |  |  226|    814|#define CBS_ASN1_T61STRING 0x14u
  ------------------
  |  Branch (40:5): [True: 57, False: 46.7k]
  ------------------
   41|    851|    case CBS_ASN1_VIDEOTEXSTRING:
  ------------------
  |  |  227|    851|#define CBS_ASN1_VIDEOTEXSTRING 0x15u
  ------------------
  |  Branch (41:5): [True: 37, False: 46.8k]
  ------------------
   42|    899|    case CBS_ASN1_IA5STRING:
  ------------------
  |  |  228|    899|#define CBS_ASN1_IA5STRING 0x16u
  ------------------
  |  Branch (42:5): [True: 48, False: 46.8k]
  ------------------
   43|    945|    case CBS_ASN1_GRAPHICSTRING:
  ------------------
  |  |  231|    945|#define CBS_ASN1_GRAPHICSTRING 0x19u
  ------------------
  |  Branch (43:5): [True: 46, False: 46.8k]
  ------------------
   44|  1.28k|    case CBS_ASN1_VISIBLESTRING:
  ------------------
  |  |  232|  1.28k|#define CBS_ASN1_VISIBLESTRING 0x1au
  ------------------
  |  Branch (44:5): [True: 339, False: 46.5k]
  ------------------
   45|  1.30k|    case CBS_ASN1_GENERALSTRING:
  ------------------
  |  |  233|  1.30k|#define CBS_ASN1_GENERALSTRING 0x1bu
  ------------------
  |  Branch (45:5): [True: 25, False: 46.8k]
  ------------------
   46|  1.31k|    case CBS_ASN1_UNIVERSALSTRING:
  ------------------
  |  |  234|  1.31k|#define CBS_ASN1_UNIVERSALSTRING 0x1cu
  ------------------
  |  Branch (46:5): [True: 10, False: 46.8k]
  ------------------
   47|  1.32k|    case CBS_ASN1_BMPSTRING:
  ------------------
  |  |  235|  1.32k|#define CBS_ASN1_BMPSTRING 0x1eu
  ------------------
  |  Branch (47:5): [True: 5, False: 46.8k]
  ------------------
   48|  1.32k|      return 1;
   49|  45.5k|    default:
  ------------------
  |  Branch (49:5): [True: 45.5k, False: 1.32k]
  ------------------
   50|  45.5k|      return 0;
   51|  46.8k|  }
   52|  46.8k|}

CBB_zero:
   27|  47.8k|void CBB_zero(CBB *cbb) {
   28|  47.8k|  OPENSSL_memset(cbb, 0, sizeof(CBB));
   29|  47.8k|}
CBB_init:
   41|    660|int CBB_init(CBB *cbb, size_t initial_capacity) {
   42|    660|  CBB_zero(cbb);
   43|       |
   44|    660|  uint8_t *buf = OPENSSL_malloc(initial_capacity);
   45|    660|  if (initial_capacity > 0 && buf == NULL) {
  ------------------
  |  Branch (45:7): [True: 660, False: 0]
  |  Branch (45:31): [True: 0, False: 660]
  ------------------
   46|      0|    return 0;
   47|      0|  }
   48|       |
   49|    660|  cbb_init(cbb, buf, initial_capacity, /*can_resize=*/1);
   50|    660|  return 1;
   51|    660|}
CBB_cleanup:
   59|    660|void CBB_cleanup(CBB *cbb) {
   60|       |  // Child |CBB|s are non-owning. They are implicitly discarded and should not
   61|       |  // be used with |CBB_cleanup| or |ScopedCBB|.
   62|    660|  assert(!cbb->is_child);
   63|    660|  if (cbb->is_child) {
  ------------------
  |  Branch (63:7): [True: 0, False: 660]
  ------------------
   64|      0|    return;
   65|      0|  }
   66|       |
   67|    660|  if (cbb->u.base.can_resize) {
  ------------------
  |  Branch (67:7): [True: 660, False: 0]
  ------------------
   68|    660|    OPENSSL_free(cbb->u.base.buf);
   69|    660|  }
   70|    660|}
CBB_finish:
  125|    273|int CBB_finish(CBB *cbb, uint8_t **out_data, size_t *out_len) {
  126|    273|  if (cbb->is_child) {
  ------------------
  |  Branch (126:7): [True: 0, False: 273]
  ------------------
  127|      0|    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
  ------------------
  |  |  441|      0|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  128|      0|    return 0;
  129|      0|  }
  130|       |
  131|    273|  if (!CBB_flush(cbb)) {
  ------------------
  |  Branch (131:7): [True: 0, False: 273]
  ------------------
  132|      0|    return 0;
  133|      0|  }
  134|       |
  135|    273|  if (cbb->u.base.can_resize && (out_data == NULL || out_len == NULL)) {
  ------------------
  |  Branch (135:7): [True: 273, False: 0]
  |  Branch (135:34): [True: 0, False: 273]
  |  Branch (135:54): [True: 0, False: 273]
  ------------------
  136|       |    // |out_data| and |out_len| can only be NULL if the CBB is fixed.
  137|      0|    return 0;
  138|      0|  }
  139|       |
  140|    273|  if (out_data != NULL) {
  ------------------
  |  Branch (140:7): [True: 273, False: 0]
  ------------------
  141|    273|    *out_data = cbb->u.base.buf;
  142|    273|  }
  143|    273|  if (out_len != NULL) {
  ------------------
  |  Branch (143:7): [True: 273, False: 0]
  ------------------
  144|    273|    *out_len = cbb->u.base.len;
  145|    273|  }
  146|    273|  cbb->u.base.buf = NULL;
  147|    273|  CBB_cleanup(cbb);
  148|    273|  return 1;
  149|    273|}
CBB_flush:
  161|   118k|int CBB_flush(CBB *cbb) {
  162|       |  // If |base| has hit an error, the buffer is in an undefined state, so
  163|       |  // fail all following calls. In particular, |cbb->child| may point to invalid
  164|       |  // memory.
  165|   118k|  struct cbb_buffer_st *base = cbb_get_base(cbb);
  166|   118k|  if (base == NULL || base->error) {
  ------------------
  |  Branch (166:7): [True: 0, False: 118k]
  |  Branch (166:23): [True: 0, False: 118k]
  ------------------
  167|      0|    return 0;
  168|      0|  }
  169|       |
  170|   118k|  if (cbb->child == NULL) {
  ------------------
  |  Branch (170:7): [True: 109k, False: 8.51k]
  ------------------
  171|       |    // Nothing to flush.
  172|   109k|    return 1;
  173|   109k|  }
  174|       |
  175|  8.51k|  assert(cbb->child->is_child);
  176|  8.51k|  struct cbb_child_st *child = &cbb->child->u.child;
  177|  8.51k|  assert(child->base == base);
  178|  8.51k|  size_t child_start = child->offset + child->pending_len_len;
  179|       |
  180|  8.51k|  if (!CBB_flush(cbb->child) ||
  ------------------
  |  Branch (180:7): [True: 0, False: 8.51k]
  ------------------
  181|  8.51k|      child_start < child->offset ||
  ------------------
  |  Branch (181:7): [True: 0, False: 8.51k]
  ------------------
  182|  8.51k|      base->len < child_start) {
  ------------------
  |  Branch (182:7): [True: 0, False: 8.51k]
  ------------------
  183|      0|    goto err;
  184|      0|  }
  185|       |
  186|  8.51k|  size_t len = base->len - child_start;
  187|       |
  188|  8.51k|  if (child->pending_is_asn1) {
  ------------------
  |  Branch (188:7): [True: 8.51k, False: 0]
  ------------------
  189|       |    // For ASN.1 we assume that we'll only need a single byte for the length.
  190|       |    // If that turned out to be incorrect, we have to move the contents along
  191|       |    // in order to make space.
  192|  8.51k|    uint8_t len_len;
  193|  8.51k|    uint8_t initial_length_byte;
  194|       |
  195|  8.51k|    assert (child->pending_len_len == 1);
  196|       |
  197|  8.51k|    if (len > 0xfffffffe) {
  ------------------
  |  Branch (197:9): [True: 0, False: 8.51k]
  ------------------
  198|      0|      OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
  ------------------
  |  |  441|      0|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  199|       |      // Too large.
  200|      0|      goto err;
  201|  8.51k|    } else if (len > 0xffffff) {
  ------------------
  |  Branch (201:16): [True: 0, False: 8.51k]
  ------------------
  202|      0|      len_len = 5;
  203|      0|      initial_length_byte = 0x80 | 4;
  204|  8.51k|    } else if (len > 0xffff) {
  ------------------
  |  Branch (204:16): [True: 1.38k, False: 7.13k]
  ------------------
  205|  1.38k|      len_len = 4;
  206|  1.38k|      initial_length_byte = 0x80 | 3;
  207|  7.13k|    } else if (len > 0xff) {
  ------------------
  |  Branch (207:16): [True: 404, False: 6.72k]
  ------------------
  208|    404|      len_len = 3;
  209|    404|      initial_length_byte = 0x80 | 2;
  210|  6.72k|    } else if (len > 0x7f) {
  ------------------
  |  Branch (210:16): [True: 393, False: 6.33k]
  ------------------
  211|    393|      len_len = 2;
  212|    393|      initial_length_byte = 0x80 | 1;
  213|  6.33k|    } else {
  214|  6.33k|      len_len = 1;
  215|  6.33k|      initial_length_byte = (uint8_t)len;
  216|  6.33k|      len = 0;
  217|  6.33k|    }
  218|       |
  219|  8.51k|    if (len_len != 1) {
  ------------------
  |  Branch (219:9): [True: 2.17k, False: 6.33k]
  ------------------
  220|       |      // We need to move the contents along in order to make space.
  221|  2.17k|      size_t extra_bytes = len_len - 1;
  222|  2.17k|      if (!cbb_buffer_add(base, NULL, extra_bytes)) {
  ------------------
  |  Branch (222:11): [True: 0, False: 2.17k]
  ------------------
  223|      0|        goto err;
  224|      0|      }
  225|  2.17k|      OPENSSL_memmove(base->buf + child_start + extra_bytes,
  226|  2.17k|                      base->buf + child_start, len);
  227|  2.17k|    }
  228|  8.51k|    base->buf[child->offset++] = initial_length_byte;
  229|  8.51k|    child->pending_len_len = len_len - 1;
  230|  8.51k|  }
  231|       |
  232|  13.8k|  for (size_t i = child->pending_len_len - 1; i < child->pending_len_len; i--) {
  ------------------
  |  Branch (232:47): [True: 5.34k, False: 8.51k]
  ------------------
  233|  5.34k|    base->buf[child->offset + i] = (uint8_t)len;
  234|  5.34k|    len >>= 8;
  235|  5.34k|  }
  236|  8.51k|  if (len != 0) {
  ------------------
  |  Branch (236:7): [True: 0, False: 8.51k]
  ------------------
  237|      0|    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
  ------------------
  |  |  441|      0|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  238|      0|    goto err;
  239|      0|  }
  240|       |
  241|  8.51k|  child->base = NULL;
  242|  8.51k|  cbb->child = NULL;
  243|       |
  244|  8.51k|  return 1;
  245|       |
  246|      0|err:
  247|      0|  base->error = 1;
  248|      0|  return 0;
  249|  8.51k|}
CBB_add_asn1:
  342|  47.2k|int CBB_add_asn1(CBB *cbb, CBB *out_contents, CBS_ASN1_TAG tag) {
  343|  47.2k|  if (!CBB_flush(cbb)) {
  ------------------
  |  Branch (343:7): [True: 0, False: 47.2k]
  ------------------
  344|      0|    return 0;
  345|      0|  }
  346|       |
  347|       |  // Split the tag into leading bits and tag number.
  348|  47.2k|  uint8_t tag_bits = (tag >> CBS_ASN1_TAG_SHIFT) & 0xe0;
  ------------------
  |  |  193|  47.2k|#define CBS_ASN1_TAG_SHIFT 24
  ------------------
  349|  47.2k|  CBS_ASN1_TAG tag_number = tag & CBS_ASN1_TAG_NUMBER_MASK;
  ------------------
  |  |  210|  47.2k|#define CBS_ASN1_TAG_NUMBER_MASK ((1u << (5 + CBS_ASN1_TAG_SHIFT)) - 1)
  |  |  ------------------
  |  |  |  |  193|  47.2k|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
  350|  47.2k|  if (tag_number >= 0x1f) {
  ------------------
  |  Branch (350:7): [True: 1.39k, False: 45.8k]
  ------------------
  351|       |    // Set all the bits in the tag number to signal high tag number form.
  352|  1.39k|    if (!CBB_add_u8(cbb, tag_bits | 0x1f) ||
  ------------------
  |  Branch (352:9): [True: 0, False: 1.39k]
  ------------------
  353|  1.39k|        !add_base128_integer(cbb, tag_number)) {
  ------------------
  |  Branch (353:9): [True: 0, False: 1.39k]
  ------------------
  354|      0|      return 0;
  355|      0|    }
  356|  45.8k|  } else if (!CBB_add_u8(cbb, tag_bits | tag_number)) {
  ------------------
  |  Branch (356:14): [True: 0, False: 45.8k]
  ------------------
  357|      0|    return 0;
  358|      0|  }
  359|       |
  360|       |  // Reserve one byte of length prefix. |CBB_flush| will finish it later.
  361|  47.2k|  return cbb_add_child(cbb, out_contents, /*len_len=*/1, /*is_asn1=*/1);
  362|  47.2k|}
CBB_add_bytes:
  364|  4.05k|int CBB_add_bytes(CBB *cbb, const uint8_t *data, size_t len) {
  365|  4.05k|  uint8_t *out;
  366|  4.05k|  if (!CBB_add_space(cbb, &out, len)) {
  ------------------
  |  Branch (366:7): [True: 0, False: 4.05k]
  ------------------
  367|      0|    return 0;
  368|      0|  }
  369|  4.05k|  OPENSSL_memcpy(out, data, len);
  370|  4.05k|  return 1;
  371|  4.05k|}
CBB_add_space:
  382|  53.4k|int CBB_add_space(CBB *cbb, uint8_t **out_data, size_t len) {
  383|  53.4k|  if (!CBB_flush(cbb) ||
  ------------------
  |  Branch (383:7): [True: 0, False: 53.4k]
  ------------------
  384|  53.4k|      !cbb_buffer_add(cbb_get_base(cbb), out_data, len)) {
  ------------------
  |  Branch (384:7): [True: 0, False: 53.4k]
  ------------------
  385|      0|    return 0;
  386|      0|  }
  387|  53.4k|  return 1;
  388|  53.4k|}
CBB_add_u8:
  430|  49.4k|int CBB_add_u8(CBB *cbb, uint8_t value) {
  431|  49.4k|  return cbb_add_u(cbb, value, 1);
  432|  49.4k|}
cbb.c:cbb_init:
   31|    660|static void cbb_init(CBB *cbb, uint8_t *buf, size_t cap, int can_resize) {
   32|    660|  cbb->is_child = 0;
   33|    660|  cbb->child = NULL;
   34|    660|  cbb->u.base.buf = buf;
   35|    660|  cbb->u.base.len = 0;
   36|    660|  cbb->u.base.cap = cap;
   37|    660|  cbb->u.base.can_resize = can_resize;
   38|    660|  cbb->u.base.error = 0;
   39|    660|}
cbb.c:cbb_get_base:
  151|   218k|static struct cbb_buffer_st *cbb_get_base(CBB *cbb) {
  152|   218k|  if (cbb->is_child) {
  ------------------
  |  Branch (152:7): [True: 202k, False: 16.4k]
  ------------------
  153|   202k|    return cbb->u.child.base;
  154|   202k|  }
  155|  16.4k|  return &cbb->u.base;
  156|   218k|}
cbb.c:cbb_buffer_add:
  116|   102k|                          size_t len) {
  117|   102k|  if (!cbb_buffer_reserve(base, out, len)) {
  ------------------
  |  Branch (117:7): [True: 0, False: 102k]
  ------------------
  118|      0|    return 0;
  119|      0|  }
  120|       |  // This will not overflow or |cbb_buffer_reserve| would have failed.
  121|   102k|  base->len += len;
  122|   102k|  return 1;
  123|   102k|}
cbb.c:add_base128_integer:
  319|  1.39k|static int add_base128_integer(CBB *cbb, uint64_t v) {
  320|  1.39k|  unsigned len_len = 0;
  321|  1.39k|  uint64_t copy = v;
  322|  3.59k|  while (copy > 0) {
  ------------------
  |  Branch (322:10): [True: 2.19k, False: 1.39k]
  ------------------
  323|  2.19k|    len_len++;
  324|  2.19k|    copy >>= 7;
  325|  2.19k|  }
  326|  1.39k|  if (len_len == 0) {
  ------------------
  |  Branch (326:7): [True: 0, False: 1.39k]
  ------------------
  327|      0|    len_len = 1;  // Zero is encoded with one byte.
  328|      0|  }
  329|  3.59k|  for (unsigned i = len_len - 1; i < len_len; i--) {
  ------------------
  |  Branch (329:34): [True: 2.19k, False: 1.39k]
  ------------------
  330|  2.19k|    uint8_t byte = (v >> (7 * i)) & 0x7f;
  331|  2.19k|    if (i != 0) {
  ------------------
  |  Branch (331:9): [True: 800, False: 1.39k]
  ------------------
  332|       |      // The high bit denotes whether there is more data.
  333|    800|      byte |= 0x80;
  334|    800|    }
  335|  2.19k|    if (!CBB_add_u8(cbb, byte)) {
  ------------------
  |  Branch (335:9): [True: 0, False: 2.19k]
  ------------------
  336|      0|      return 0;
  337|      0|    }
  338|  2.19k|  }
  339|  1.39k|  return 1;
  340|  1.39k|}
cbb.c:cbb_add_child:
  272|  47.2k|                         int is_asn1) {
  273|  47.2k|  assert(cbb->child == NULL);
  274|  47.2k|  assert(!is_asn1 || len_len == 1);
  275|  47.2k|  struct cbb_buffer_st *base = cbb_get_base(cbb);
  276|  47.2k|  size_t offset = base->len;
  277|       |
  278|       |  // Reserve space for the length prefix.
  279|  47.2k|  uint8_t *prefix_bytes;
  280|  47.2k|  if (!cbb_buffer_add(base, &prefix_bytes, len_len)) {
  ------------------
  |  Branch (280:7): [True: 0, False: 47.2k]
  ------------------
  281|      0|    return 0;
  282|      0|  }
  283|  47.2k|  OPENSSL_memset(prefix_bytes, 0, len_len);
  284|       |
  285|  47.2k|  CBB_zero(out_child);
  286|  47.2k|  out_child->is_child = 1;
  287|  47.2k|  out_child->u.child.base = base;
  288|  47.2k|  out_child->u.child.offset = offset;
  289|  47.2k|  out_child->u.child.pending_len_len = len_len;
  290|  47.2k|  out_child->u.child.pending_is_asn1 = is_asn1;
  291|  47.2k|  cbb->child = out_child;
  292|  47.2k|  return 1;
  293|  47.2k|}
cbb.c:cbb_buffer_reserve:
   73|   102k|                              size_t len) {
   74|   102k|  if (base == NULL) {
  ------------------
  |  Branch (74:7): [True: 0, False: 102k]
  ------------------
   75|      0|    return 0;
   76|      0|  }
   77|       |
   78|   102k|  size_t newlen = base->len + len;
   79|   102k|  if (newlen < base->len) {
  ------------------
  |  Branch (79:7): [True: 0, False: 102k]
  ------------------
   80|       |    // Overflow
   81|      0|    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
  ------------------
  |  |  441|      0|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
   82|      0|    goto err;
   83|      0|  }
   84|       |
   85|   102k|  if (newlen > base->cap) {
  ------------------
  |  Branch (85:7): [True: 63, False: 102k]
  ------------------
   86|     63|    if (!base->can_resize) {
  ------------------
  |  Branch (86:9): [True: 0, False: 63]
  ------------------
   87|      0|      OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
  ------------------
  |  |  441|      0|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
   88|      0|      goto err;
   89|      0|    }
   90|       |
   91|     63|    size_t newcap = base->cap * 2;
   92|     63|    if (newcap < base->cap || newcap < newlen) {
  ------------------
  |  Branch (92:9): [True: 0, False: 63]
  |  Branch (92:31): [True: 0, False: 63]
  ------------------
   93|      0|      newcap = newlen;
   94|      0|    }
   95|     63|    uint8_t *newbuf = OPENSSL_realloc(base->buf, newcap);
   96|     63|    if (newbuf == NULL) {
  ------------------
  |  Branch (96:9): [True: 0, False: 63]
  ------------------
   97|      0|      goto err;
   98|      0|    }
   99|       |
  100|     63|    base->buf = newbuf;
  101|     63|    base->cap = newcap;
  102|     63|  }
  103|       |
  104|   102k|  if (out) {
  ------------------
  |  Branch (104:7): [True: 100k, False: 2.17k]
  ------------------
  105|   100k|    *out = base->buf + base->len;
  106|   100k|  }
  107|       |
  108|   102k|  return 1;
  109|       |
  110|      0|err:
  111|      0|  base->error = 1;
  112|      0|  return 0;
  113|   102k|}
cbb.c:cbb_add_u:
  410|  49.4k|static int cbb_add_u(CBB *cbb, uint64_t v, size_t len_len) {
  411|  49.4k|  uint8_t *buf;
  412|  49.4k|  if (!CBB_add_space(cbb, &buf, len_len)) {
  ------------------
  |  Branch (412:7): [True: 0, False: 49.4k]
  ------------------
  413|      0|    return 0;
  414|      0|  }
  415|       |
  416|  98.8k|  for (size_t i = len_len - 1; i < len_len; i--) {
  ------------------
  |  Branch (416:32): [True: 49.4k, False: 49.4k]
  ------------------
  417|  49.4k|    buf[i] = v;
  418|  49.4k|    v >>= 8;
  419|  49.4k|  }
  420|       |
  421|       |  // |v| must fit in |len_len| bytes.
  422|  49.4k|  if (v != 0) {
  ------------------
  |  Branch (422:7): [True: 0, False: 49.4k]
  ------------------
  423|      0|    cbb_get_base(cbb)->error = 1;
  424|      0|    return 0;
  425|      0|  }
  426|       |
  427|  49.4k|  return 1;
  428|  49.4k|}

CBS_init:
   29|  63.8k|void CBS_init(CBS *cbs, const uint8_t *data, size_t len) {
   30|  63.8k|  cbs->data = data;
   31|  63.8k|  cbs->len = len;
   32|  63.8k|}
CBS_skip:
   45|  14.4k|int CBS_skip(CBS *cbs, size_t len) {
   46|  14.4k|  const uint8_t *dummy;
   47|  14.4k|  return cbs_get(cbs, &dummy, len);
   48|  14.4k|}
CBS_data:
   50|  53.4k|const uint8_t *CBS_data(const CBS *cbs) {
   51|  53.4k|  return cbs->data;
   52|  53.4k|}
CBS_len:
   54|   228k|size_t CBS_len(const CBS *cbs) {
   55|   228k|  return cbs->len;
   56|   228k|}
CBS_mem_equal:
   86|     43|int CBS_mem_equal(const CBS *cbs, const uint8_t *data, size_t len) {
   87|     43|  if (len != cbs->len) {
  ------------------
  |  Branch (87:7): [True: 38, False: 5]
  ------------------
   88|     38|    return 0;
   89|     38|  }
   90|      5|  return CRYPTO_memcmp(cbs->data, data, len) == 0;
   91|     43|}
CBS_get_u8:
  108|   121k|int CBS_get_u8(CBS *cbs, uint8_t *out) {
  109|   121k|  const uint8_t *v;
  110|   121k|  if (!cbs_get(cbs, &v, 1)) {
  ------------------
  |  Branch (110:7): [True: 333, False: 121k]
  ------------------
  111|    333|    return 0;
  112|    333|  }
  113|   121k|  *out = *v;
  114|   121k|  return 1;
  115|   121k|}
CBS_get_bytes:
  181|  56.2k|int CBS_get_bytes(CBS *cbs, CBS *out, size_t len) {
  182|  56.2k|  const uint8_t *v;
  183|  56.2k|  if (!cbs_get(cbs, &v, len)) {
  ------------------
  |  Branch (183:7): [True: 293, False: 55.9k]
  ------------------
  184|    293|    return 0;
  185|    293|  }
  186|  55.9k|  CBS_init(out, v, len);
  187|  55.9k|  return 1;
  188|  56.2k|}
CBS_get_any_asn1_element:
  436|  2.42k|                                    size_t *out_header_len) {
  437|  2.42k|  return cbs_get_any_asn1_element(cbs, out, out_tag, out_header_len, NULL, NULL,
  438|  2.42k|                                  /*ber_ok=*/0);
  439|  2.42k|}
CBS_get_any_ber_asn1_element:
  443|  54.7k|                                 int *out_indefinite) {
  444|  54.7k|  int ber_found_temp;
  445|  54.7k|  return cbs_get_any_asn1_element(
  446|  54.7k|      cbs, out, out_tag, out_header_len,
  447|  54.7k|      out_ber_found ? out_ber_found : &ber_found_temp, out_indefinite,
  ------------------
  |  Branch (447:7): [True: 7.00k, False: 47.7k]
  ------------------
  448|  54.7k|      /*ber_ok=*/1);
  449|  54.7k|}
CBS_get_asn1:
  474|  1.70k|int CBS_get_asn1(CBS *cbs, CBS *out, CBS_ASN1_TAG tag_value) {
  475|  1.70k|  return cbs_get_asn1(cbs, out, tag_value, 1 /* skip header */);
  476|  1.70k|}
CBS_get_asn1_uint64:
  488|    355|int CBS_get_asn1_uint64(CBS *cbs, uint64_t *out) {
  489|    355|  CBS bytes;
  490|    355|  if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_INTEGER) ||
  ------------------
  |  |  215|    355|#define CBS_ASN1_INTEGER 0x2u
  ------------------
  |  Branch (490:7): [True: 84, False: 271]
  ------------------
  491|    355|      !CBS_is_unsigned_asn1_integer(&bytes)) {
  ------------------
  |  Branch (491:7): [True: 28, False: 243]
  ------------------
  492|    112|    return 0;
  493|    112|  }
  494|       |
  495|    243|  *out = 0;
  496|    243|  const uint8_t *data = CBS_data(&bytes);
  497|    243|  size_t len = CBS_len(&bytes);
  498|  1.61k|  for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (498:22): [True: 1.42k, False: 193]
  ------------------
  499|  1.42k|    if ((*out >> 56) != 0) {
  ------------------
  |  Branch (499:9): [True: 50, False: 1.37k]
  ------------------
  500|       |      // Too large to represent as a uint64_t.
  501|     50|      return 0;
  502|     50|    }
  503|  1.37k|    *out <<= 8;
  504|  1.37k|    *out |= data[i];
  505|  1.37k|  }
  506|       |
  507|    193|  return 1;
  508|    243|}
CBS_is_valid_asn1_integer:
  671|    271|int CBS_is_valid_asn1_integer(const CBS *cbs, int *out_is_negative) {
  672|    271|  CBS copy = *cbs;
  673|    271|  uint8_t first_byte, second_byte;
  674|    271|  if (!CBS_get_u8(&copy, &first_byte)) {
  ------------------
  |  Branch (674:7): [True: 1, False: 270]
  ------------------
  675|      1|    return 0;  // INTEGERs may not be empty.
  676|      1|  }
  677|    270|  if (out_is_negative != NULL) {
  ------------------
  |  Branch (677:7): [True: 270, False: 0]
  ------------------
  678|    270|    *out_is_negative = (first_byte & 0x80) != 0;
  679|    270|  }
  680|    270|  if (!CBS_get_u8(&copy, &second_byte)) {
  ------------------
  |  Branch (680:7): [True: 64, False: 206]
  ------------------
  681|     64|    return 1;  // One byte INTEGERs are always minimal.
  682|     64|  }
  683|    206|  if ((first_byte == 0x00 && (second_byte & 0x80) == 0) ||
  ------------------
  |  Branch (683:8): [True: 86, False: 120]
  |  Branch (683:30): [True: 7, False: 79]
  ------------------
  684|    206|      (first_byte == 0xff && (second_byte & 0x80) != 0)) {
  ------------------
  |  Branch (684:8): [True: 14, False: 185]
  |  Branch (684:30): [True: 8, False: 6]
  ------------------
  685|     15|    return 0;  // The value is minimal iff the first 9 bits are not all equal.
  686|     15|  }
  687|    191|  return 1;
  688|    206|}
CBS_is_unsigned_asn1_integer:
  690|    271|int CBS_is_unsigned_asn1_integer(const CBS *cbs) {
  691|    271|  int is_negative;
  692|    271|  return CBS_is_valid_asn1_integer(cbs, &is_negative) && !is_negative;
  ------------------
  |  Branch (692:10): [True: 255, False: 16]
  |  Branch (692:58): [True: 243, False: 12]
  ------------------
  693|    271|}
cbs.c:cbs_get:
   34|   195k|static int cbs_get(CBS *cbs, const uint8_t **p, size_t n) {
   35|   195k|  if (cbs->len < n) {
  ------------------
  |  Branch (35:7): [True: 633, False: 194k]
  ------------------
   36|    633|    return 0;
   37|    633|  }
   38|       |
   39|   194k|  *p = cbs->data;
   40|   194k|  cbs->data += n;
   41|   194k|  cbs->len -= n;
   42|   194k|  return 1;
   43|   195k|}
cbs.c:cbs_get_u:
   93|  2.62k|static int cbs_get_u(CBS *cbs, uint64_t *out, size_t len) {
   94|  2.62k|  uint64_t result = 0;
   95|  2.62k|  const uint8_t *data;
   96|       |
   97|  2.62k|  if (!cbs_get(cbs, &data, len)) {
  ------------------
  |  Branch (97:7): [True: 7, False: 2.62k]
  ------------------
   98|      7|    return 0;
   99|      7|  }
  100|  7.59k|  for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (100:22): [True: 4.97k, False: 2.62k]
  ------------------
  101|  4.97k|    result <<= 8;
  102|  4.97k|    result |= data[i];
  103|  4.97k|  }
  104|  2.62k|  *out = result;
  105|  2.62k|  return 1;
  106|  2.62k|}
cbs.c:cbs_get_any_asn1_element:
  322|  57.1k|                                    int *out_indefinite, int ber_ok) {
  323|  57.1k|  CBS header = *cbs;
  324|  57.1k|  CBS throwaway;
  325|       |
  326|  57.1k|  if (out == NULL) {
  ------------------
  |  Branch (326:7): [True: 0, False: 57.1k]
  ------------------
  327|      0|    out = &throwaway;
  328|      0|  }
  329|  57.1k|  if (ber_ok) {
  ------------------
  |  Branch (329:7): [True: 54.7k, False: 2.42k]
  ------------------
  330|  54.7k|    *out_ber_found = 0;
  331|  54.7k|    *out_indefinite = 0;
  332|  54.7k|  } else {
  333|  2.42k|    assert(out_ber_found == NULL);
  334|  2.42k|    assert(out_indefinite == NULL);
  335|  2.42k|  }
  336|       |
  337|  57.1k|  CBS_ASN1_TAG tag;
  338|  57.1k|  if (!parse_asn1_tag(&header, &tag)) {
  ------------------
  |  Branch (338:7): [True: 687, False: 56.4k]
  ------------------
  339|    687|    return 0;
  340|    687|  }
  341|  56.4k|  if (out_tag != NULL) {
  ------------------
  |  Branch (341:7): [True: 55.7k, False: 722]
  ------------------
  342|  55.7k|    *out_tag = tag;
  343|  55.7k|  }
  344|       |
  345|  56.4k|  uint8_t length_byte;
  346|  56.4k|  if (!CBS_get_u8(&header, &length_byte)) {
  ------------------
  |  Branch (346:7): [True: 43, False: 56.4k]
  ------------------
  347|     43|    return 0;
  348|     43|  }
  349|       |
  350|  56.4k|  size_t header_len = CBS_len(cbs) - CBS_len(&header);
  351|       |
  352|  56.4k|  size_t len;
  353|       |  // The format for the length encoding is specified in ITU-T X.690 section
  354|       |  // 8.1.3.
  355|  56.4k|  if ((length_byte & 0x80) == 0) {
  ------------------
  |  Branch (355:7): [True: 13.9k, False: 42.5k]
  ------------------
  356|       |    // Short form length.
  357|  13.9k|    len = ((size_t) length_byte) + header_len;
  358|  13.9k|    if (out_header_len != NULL) {
  ------------------
  |  Branch (358:9): [True: 13.4k, False: 432]
  ------------------
  359|  13.4k|      *out_header_len = header_len;
  360|  13.4k|    }
  361|  42.5k|  } else {
  362|       |    // The high bit indicate that this is the long form, while the next 7 bits
  363|       |    // encode the number of subsequent octets used to encode the length (ITU-T
  364|       |    // X.690 clause 8.1.3.5.b).
  365|  42.5k|    const size_t num_bytes = length_byte & 0x7f;
  366|  42.5k|    uint64_t len64;
  367|       |
  368|  42.5k|    if (ber_ok && (tag & CBS_ASN1_CONSTRUCTED) != 0 && num_bytes == 0) {
  ------------------
  |  |  196|  41.6k|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  ------------------
  |  |  |  |  193|  41.6k|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
  |  Branch (368:9): [True: 41.6k, False: 854]
  |  Branch (368:19): [True: 40.2k, False: 1.36k]
  |  Branch (368:56): [True: 39.7k, False: 538]
  ------------------
  369|       |      // indefinite length
  370|  39.7k|      if (out_header_len != NULL) {
  ------------------
  |  Branch (370:11): [True: 39.7k, False: 0]
  ------------------
  371|  39.7k|        *out_header_len = header_len;
  372|  39.7k|      }
  373|  39.7k|      *out_ber_found = 1;
  374|  39.7k|      *out_indefinite = 1;
  375|  39.7k|      return CBS_get_bytes(cbs, out, header_len);
  376|  39.7k|    }
  377|       |
  378|       |    // ITU-T X.690 clause 8.1.3.5.c specifies that the value 0xff shall not be
  379|       |    // used as the first byte of the length. If this parser encounters that
  380|       |    // value, num_bytes will be parsed as 127, which will fail this check.
  381|  2.76k|    if (num_bytes == 0 || num_bytes > 4) {
  ------------------
  |  Branch (381:9): [True: 115, False: 2.64k]
  |  Branch (381:27): [True: 18, False: 2.62k]
  ------------------
  382|    133|      return 0;
  383|    133|    }
  384|  2.62k|    if (!cbs_get_u(&header, &len64, num_bytes)) {
  ------------------
  |  Branch (384:9): [True: 7, False: 2.62k]
  ------------------
  385|      7|      return 0;
  386|      7|    }
  387|       |    // ITU-T X.690 section 10.1 (DER length forms) requires encoding the
  388|       |    // length with the minimum number of octets. BER could, technically, have
  389|       |    // 125 superfluous zero bytes. We do not attempt to handle that and still
  390|       |    // require that the length fit in a |uint32_t| for BER.
  391|  2.62k|    if (len64 < 128) {
  ------------------
  |  Branch (391:9): [True: 739, False: 1.88k]
  ------------------
  392|       |      // Length should have used short-form encoding.
  393|    739|      if (ber_ok) {
  ------------------
  |  Branch (393:11): [True: 738, False: 1]
  ------------------
  394|    738|        *out_ber_found = 1;
  395|    738|      } else {
  396|      1|        return 0;
  397|      1|      }
  398|    739|    }
  399|  2.61k|    if ((len64 >> ((num_bytes - 1) * 8)) == 0) {
  ------------------
  |  Branch (399:9): [True: 489, False: 2.13k]
  ------------------
  400|       |      // Length should have been at least one byte shorter.
  401|    489|      if (ber_ok) {
  ------------------
  |  Branch (401:11): [True: 488, False: 1]
  ------------------
  402|    488|        *out_ber_found = 1;
  403|    488|      } else {
  404|      1|        return 0;
  405|      1|      }
  406|    489|    }
  407|  2.61k|    len = len64;
  408|  2.61k|    if (len + header_len + num_bytes < len) {
  ------------------
  |  Branch (408:9): [True: 0, False: 2.61k]
  ------------------
  409|       |      // Overflow.
  410|      0|      return 0;
  411|      0|    }
  412|  2.61k|    len += header_len + num_bytes;
  413|  2.61k|    if (out_header_len != NULL) {
  ------------------
  |  Branch (413:9): [True: 2.32k, False: 290]
  ------------------
  414|  2.32k|      *out_header_len = header_len + num_bytes;
  415|  2.32k|    }
  416|  2.61k|  }
  417|       |
  418|  16.5k|  return CBS_get_bytes(cbs, out, len);
  419|  56.4k|}
cbs.c:cbs_get_asn1:
  452|  1.70k|                        int skip_header) {
  453|  1.70k|  size_t header_len;
  454|  1.70k|  CBS_ASN1_TAG tag;
  455|  1.70k|  CBS throwaway;
  456|       |
  457|  1.70k|  if (out == NULL) {
  ------------------
  |  Branch (457:7): [True: 0, False: 1.70k]
  ------------------
  458|      0|    out = &throwaway;
  459|      0|  }
  460|       |
  461|  1.70k|  if (!CBS_get_any_asn1_element(cbs, out, &tag, &header_len) ||
  ------------------
  |  Branch (461:7): [True: 133, False: 1.57k]
  ------------------
  462|  1.70k|      tag != tag_value) {
  ------------------
  |  Branch (462:7): [True: 727, False: 844]
  ------------------
  463|    860|    return 0;
  464|    860|  }
  465|       |
  466|    844|  if (skip_header && !CBS_skip(out, header_len)) {
  ------------------
  |  Branch (466:7): [True: 844, False: 0]
  |  Branch (466:22): [True: 0, False: 844]
  ------------------
  467|      0|    assert(0);
  468|      0|    return 0;
  469|      0|  }
  470|       |
  471|    844|  return 1;
  472|    844|}
cbs.c:parse_asn1_tag:
  281|  57.1k|static int parse_asn1_tag(CBS *cbs, CBS_ASN1_TAG *out) {
  282|  57.1k|  uint8_t tag_byte;
  283|  57.1k|  if (!CBS_get_u8(cbs, &tag_byte)) {
  ------------------
  |  Branch (283:7): [True: 130, False: 57.0k]
  ------------------
  284|    130|    return 0;
  285|    130|  }
  286|       |
  287|       |  // ITU-T X.690 section 8.1.2.3 specifies the format for identifiers with a tag
  288|       |  // number no greater than 30.
  289|       |  //
  290|       |  // If the number portion is 31 (0x1f, the largest value that fits in the
  291|       |  // allotted bits), then the tag is more than one byte long and the
  292|       |  // continuation bytes contain the tag number.
  293|  57.0k|  CBS_ASN1_TAG tag = ((CBS_ASN1_TAG)tag_byte & 0xe0) << CBS_ASN1_TAG_SHIFT;
  ------------------
  |  |  193|  57.0k|#define CBS_ASN1_TAG_SHIFT 24
  ------------------
  294|  57.0k|  CBS_ASN1_TAG tag_number = tag_byte & 0x1f;
  295|  57.0k|  if (tag_number == 0x1f) {
  ------------------
  |  Branch (295:7): [True: 3.04k, False: 53.9k]
  ------------------
  296|  3.04k|    uint64_t v;
  297|  3.04k|    if (!parse_base128_integer(cbs, &v) ||
  ------------------
  |  Branch (297:9): [True: 96, False: 2.94k]
  ------------------
  298|       |        // Check the tag number is within our supported bounds.
  299|  3.04k|        v > CBS_ASN1_TAG_NUMBER_MASK ||
  ------------------
  |  |  210|  5.99k|#define CBS_ASN1_TAG_NUMBER_MASK ((1u << (5 + CBS_ASN1_TAG_SHIFT)) - 1)
  |  |  ------------------
  |  |  |  |  193|  2.94k|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
  |  Branch (299:9): [True: 144, False: 2.80k]
  ------------------
  300|       |        // Small tag numbers should have used low tag number form, even in BER.
  301|  3.04k|        v < 0x1f) {
  ------------------
  |  Branch (301:9): [True: 5, False: 2.79k]
  ------------------
  302|    245|      return 0;
  303|    245|    }
  304|  2.79k|    tag_number = (CBS_ASN1_TAG)v;
  305|  2.79k|  }
  306|       |
  307|  56.7k|  tag |= tag_number;
  308|       |
  309|       |  // Tag [UNIVERSAL 0] is reserved for use by the encoding. Reject it here to
  310|       |  // avoid some ambiguity around ANY values and BER indefinite-length EOCs. See
  311|       |  // https://crbug.com/boringssl/455.
  312|  56.7k|  if ((tag & ~CBS_ASN1_CONSTRUCTED) == 0) {
  ------------------
  |  |  196|  56.7k|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  ------------------
  |  |  |  |  193|  56.7k|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
  |  Branch (312:7): [True: 312, False: 56.4k]
  ------------------
  313|    312|    return 0;
  314|    312|  }
  315|       |
  316|  56.4k|  *out = tag;
  317|  56.4k|  return 1;
  318|  56.7k|}
cbs.c:parse_base128_integer:
  257|  3.04k|static int parse_base128_integer(CBS *cbs, uint64_t *out) {
  258|  3.04k|  uint64_t v = 0;
  259|  3.04k|  uint8_t b;
  260|  7.62k|  do {
  261|  7.62k|    if (!CBS_get_u8(cbs, &b)) {
  ------------------
  |  Branch (261:9): [True: 95, False: 7.52k]
  ------------------
  262|     95|      return 0;
  263|     95|    }
  264|  7.52k|    if ((v >> (64 - 7)) != 0) {
  ------------------
  |  Branch (264:9): [True: 0, False: 7.52k]
  ------------------
  265|       |      // The value is too large.
  266|      0|      return 0;
  267|      0|    }
  268|  7.52k|    if (v == 0 && b == 0x80) {
  ------------------
  |  Branch (268:9): [True: 3.04k, False: 4.48k]
  |  Branch (268:19): [True: 1, False: 3.04k]
  ------------------
  269|       |      // The value must be minimally encoded.
  270|      1|      return 0;
  271|      1|    }
  272|  7.52k|    v = (v << 7) | (b & 0x7f);
  273|       |
  274|       |    // Values end at an octet with the high bit cleared.
  275|  7.52k|  } while (b & 0x80);
  ------------------
  |  Branch (275:12): [True: 4.57k, False: 2.94k]
  ------------------
  276|       |
  277|  2.94k|  *out = v;
  278|  2.94k|  return 1;
  279|  3.04k|}

OPENSSL_cpuid_setup:
  153|      2|void OPENSSL_cpuid_setup(void) {
  154|       |  // Determine the vendor and maximum input value.
  155|      2|  uint32_t eax, ebx, ecx, edx;
  156|      2|  OPENSSL_cpuid(&eax, &ebx, &ecx, &edx, 0);
  157|       |
  158|      2|  uint32_t num_ids = eax;
  159|       |
  160|      2|  int is_intel = ebx == 0x756e6547 /* Genu */ &&
  ------------------
  |  Branch (160:18): [True: 2, False: 0]
  ------------------
  161|      2|                 edx == 0x49656e69 /* ineI */ &&
  ------------------
  |  Branch (161:18): [True: 2, False: 0]
  ------------------
  162|      2|                 ecx == 0x6c65746e /* ntel */;
  ------------------
  |  Branch (162:18): [True: 2, False: 0]
  ------------------
  163|      2|  int is_amd = ebx == 0x68747541 /* Auth */ &&
  ------------------
  |  Branch (163:16): [True: 0, False: 2]
  ------------------
  164|      2|               edx == 0x69746e65 /* enti */ &&
  ------------------
  |  Branch (164:16): [True: 0, False: 0]
  ------------------
  165|      2|               ecx == 0x444d4163 /* cAMD */;
  ------------------
  |  Branch (165:16): [True: 0, False: 0]
  ------------------
  166|       |
  167|      2|  uint32_t extended_features[2] = {0};
  168|      2|  if (num_ids >= 7) {
  ------------------
  |  Branch (168:7): [True: 2, False: 0]
  ------------------
  169|      2|    OPENSSL_cpuid(&eax, &ebx, &ecx, &edx, 7);
  170|      2|    extended_features[0] = ebx;
  171|      2|    extended_features[1] = ecx;
  172|      2|  }
  173|       |
  174|      2|  OPENSSL_cpuid(&eax, &ebx, &ecx, &edx, 1);
  175|       |
  176|      2|  if (is_amd) {
  ------------------
  |  Branch (176:7): [True: 0, False: 2]
  ------------------
  177|       |    // See https://www.amd.com/system/files/TechDocs/25481.pdf, page 10.
  178|      0|    const uint32_t base_family = (eax >> 8) & 15;
  179|      0|    const uint32_t base_model = (eax >> 4) & 15;
  180|       |
  181|      0|    uint32_t family = base_family;
  182|      0|    uint32_t model = base_model;
  183|      0|    if (base_family == 0xf) {
  ------------------
  |  Branch (183:9): [True: 0, False: 0]
  ------------------
  184|      0|      const uint32_t ext_family = (eax >> 20) & 255;
  185|      0|      family += ext_family;
  186|      0|      const uint32_t ext_model = (eax >> 16) & 15;
  187|      0|      model |= ext_model << 4;
  188|      0|    }
  189|       |
  190|      0|    if (family < 0x17 || (family == 0x17 && 0x70 <= model && model <= 0x7f)) {
  ------------------
  |  Branch (190:9): [True: 0, False: 0]
  |  Branch (190:27): [True: 0, False: 0]
  |  Branch (190:45): [True: 0, False: 0]
  |  Branch (190:62): [True: 0, False: 0]
  ------------------
  191|       |      // Disable RDRAND on AMD families before 0x17 (Zen) due to reported
  192|       |      // failures after suspend.
  193|       |      // https://bugzilla.redhat.com/show_bug.cgi?id=1150286
  194|       |      // Also disable for family 0x17, models 0x70–0x7f, due to possible RDRAND
  195|       |      // failures there too.
  196|      0|      ecx &= ~(1u << 30);
  197|      0|    }
  198|      0|  }
  199|       |
  200|       |  // Force the hyper-threading bit so that the more conservative path is always
  201|       |  // chosen.
  202|      2|  edx |= 1u << 28;
  203|       |
  204|       |  // Reserved bit #20 was historically repurposed to control the in-memory
  205|       |  // representation of RC4 state. Always set it to zero.
  206|      2|  edx &= ~(1u << 20);
  207|       |
  208|       |  // Reserved bit #30 is repurposed to signal an Intel CPU.
  209|      2|  if (is_intel) {
  ------------------
  |  Branch (209:7): [True: 2, False: 0]
  ------------------
  210|      2|    edx |= (1u << 30);
  211|       |
  212|       |    // Clear the XSAVE bit on Knights Landing to mimic Silvermont. This enables
  213|       |    // some Silvermont-specific codepaths which perform better. See OpenSSL
  214|       |    // commit 64d92d74985ebb3d0be58a9718f9e080a14a8e7f.
  215|      2|    if ((eax & 0x0fff0ff0) == 0x00050670 /* Knights Landing */ ||
  ------------------
  |  Branch (215:9): [True: 0, False: 2]
  ------------------
  216|      2|        (eax & 0x0fff0ff0) == 0x00080650 /* Knights Mill (per SDE) */) {
  ------------------
  |  Branch (216:9): [True: 0, False: 2]
  ------------------
  217|      0|      ecx &= ~(1u << 26);
  218|      0|    }
  219|      2|  } else {
  220|      0|    edx &= ~(1u << 30);
  221|      0|  }
  222|       |
  223|       |  // The SDBG bit is repurposed to denote AMD XOP support. Don't ever use AMD
  224|       |  // XOP code paths.
  225|      2|  ecx &= ~(1u << 11);
  226|       |
  227|      2|  uint64_t xcr0 = 0;
  228|      2|  if (ecx & (1u << 27)) {
  ------------------
  |  Branch (228:7): [True: 2, False: 0]
  ------------------
  229|       |    // XCR0 may only be queried if the OSXSAVE bit is set.
  230|      2|    xcr0 = OPENSSL_xgetbv(0);
  231|      2|  }
  232|       |  // See Intel manual, volume 1, section 14.3.
  233|      2|  if ((xcr0 & 6) != 6) {
  ------------------
  |  Branch (233:7): [True: 0, False: 2]
  ------------------
  234|       |    // YMM registers cannot be used.
  235|      0|    ecx &= ~(1u << 28);  // AVX
  236|      0|    ecx &= ~(1u << 12);  // FMA
  237|      0|    ecx &= ~(1u << 11);  // AMD XOP
  238|       |    // Clear AVX2 and AVX512* bits.
  239|       |    //
  240|       |    // TODO(davidben): Should bits 17 and 26-28 also be cleared? Upstream
  241|       |    // doesn't clear those.
  242|      0|    extended_features[0] &=
  243|      0|        ~((1u << 5) | (1u << 16) | (1u << 21) | (1u << 30) | (1u << 31));
  244|      0|  }
  245|       |  // See Intel manual, volume 1, section 15.2.
  246|      2|  if ((xcr0 & 0xe6) != 0xe6) {
  ------------------
  |  Branch (246:7): [True: 2, False: 0]
  ------------------
  247|       |    // Clear AVX512F. Note we don't touch other AVX512 extensions because they
  248|       |    // can be used with YMM.
  249|      2|    extended_features[0] &= ~(1u << 16);
  250|      2|  }
  251|       |
  252|       |  // Disable ADX instructions on Knights Landing. See OpenSSL commit
  253|       |  // 64d92d74985ebb3d0be58a9718f9e080a14a8e7f.
  254|      2|  if ((ecx & (1u << 26)) == 0) {
  ------------------
  |  Branch (254:7): [True: 0, False: 2]
  ------------------
  255|      0|    extended_features[0] &= ~(1u << 19);
  256|      0|  }
  257|       |
  258|      2|  OPENSSL_ia32cap_P[0] = edx;
  259|      2|  OPENSSL_ia32cap_P[1] = ecx;
  260|      2|  OPENSSL_ia32cap_P[2] = extended_features[0];
  261|      2|  OPENSSL_ia32cap_P[3] = extended_features[1];
  262|       |
  263|      2|  const char *env1, *env2;
  264|      2|  env1 = getenv("OPENSSL_ia32cap");
  265|      2|  if (env1 == NULL) {
  ------------------
  |  Branch (265:7): [True: 2, False: 0]
  ------------------
  266|      2|    return;
  267|      2|  }
  268|       |
  269|       |  // OPENSSL_ia32cap can contain zero, one or two values, separated with a ':'.
  270|       |  // Each value is a 64-bit, unsigned value which may start with "0x" to
  271|       |  // indicate a hex value. Prior to the 64-bit value, a '~' or '|' may be given.
  272|       |  //
  273|       |  // If the '~' prefix is present:
  274|       |  //   the value is inverted and ANDed with the probed CPUID result
  275|       |  // If the '|' prefix is present:
  276|       |  //   the value is ORed with the probed CPUID result
  277|       |  // Otherwise:
  278|       |  //   the value is taken as the result of the CPUID
  279|       |  //
  280|       |  // The first value determines OPENSSL_ia32cap_P[0] and [1]. The second [2]
  281|       |  // and [3].
  282|       |
  283|      0|  handle_cpu_env(&OPENSSL_ia32cap_P[0], env1);
  284|      0|  env2 = strchr(env1, ':');
  285|      0|  if (env2 != NULL) {
  ------------------
  |  Branch (285:7): [True: 0, False: 0]
  ------------------
  286|      0|    handle_cpu_env(&OPENSSL_ia32cap_P[2], env2 + 1);
  287|      0|  }
  288|      0|}
cpu_intel.c:OPENSSL_cpuid:
   80|      6|                          uint32_t *out_ecx, uint32_t *out_edx, uint32_t leaf) {
   81|       |#if defined(_MSC_VER)
   82|       |  int tmp[4];
   83|       |  __cpuid(tmp, (int)leaf);
   84|       |  *out_eax = (uint32_t)tmp[0];
   85|       |  *out_ebx = (uint32_t)tmp[1];
   86|       |  *out_ecx = (uint32_t)tmp[2];
   87|       |  *out_edx = (uint32_t)tmp[3];
   88|       |#elif defined(__pic__) && defined(OPENSSL_32_BIT)
   89|       |  // Inline assembly may not clobber the PIC register. For 32-bit, this is EBX.
   90|       |  // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47602.
   91|       |  __asm__ volatile (
   92|       |    "xor %%ecx, %%ecx\n"
   93|       |    "mov %%ebx, %%edi\n"
   94|       |    "cpuid\n"
   95|       |    "xchg %%edi, %%ebx\n"
   96|       |    : "=a"(*out_eax), "=D"(*out_ebx), "=c"(*out_ecx), "=d"(*out_edx)
   97|       |    : "a"(leaf)
   98|       |  );
   99|       |#else
  100|      6|  __asm__ volatile (
  101|      6|    "xor %%ecx, %%ecx\n"
  102|      6|    "cpuid\n"
  103|      6|    : "=a"(*out_eax), "=b"(*out_ebx), "=c"(*out_ecx), "=d"(*out_edx)
  104|      6|    : "a"(leaf)
  105|      6|  );
  106|      6|#endif
  107|      6|}
cpu_intel.c:OPENSSL_xgetbv:
  111|      2|static uint64_t OPENSSL_xgetbv(uint32_t xcr) {
  112|       |#if defined(_MSC_VER)
  113|       |  return (uint64_t)_xgetbv(xcr);
  114|       |#else
  115|      2|  uint32_t eax, edx;
  116|      2|  __asm__ volatile ("xgetbv" : "=a"(eax), "=d"(edx) : "c"(xcr));
  117|      2|  return (((uint64_t)edx) << 32) | eax;
  118|      2|#endif
  119|      2|}

crypto.c:do_library_init:
  151|      2|static void OPENSSL_CDECL do_library_init(void) {
  152|       | // WARNING: this function may only configure the capability variables. See the
  153|       | // note above about the linker bug.
  154|      2|#if defined(NEED_CPUID)
  155|      2|  OPENSSL_cpuid_setup();
  156|      2|#endif
  157|      2|}

ERR_put_error:
  657|  2.18k|                   unsigned line) {
  658|  2.18k|  ERR_STATE *const state = err_get_state();
  659|  2.18k|  struct err_error_st *error;
  660|       |
  661|  2.18k|  if (state == NULL) {
  ------------------
  |  Branch (661:7): [True: 0, False: 2.18k]
  ------------------
  662|      0|    return;
  663|      0|  }
  664|       |
  665|  2.18k|  if (library == ERR_LIB_SYS && reason == 0) {
  ------------------
  |  Branch (665:7): [True: 0, False: 2.18k]
  |  Branch (665:33): [True: 0, False: 0]
  ------------------
  666|       |#if defined(OPENSSL_WINDOWS)
  667|       |    reason = GetLastError();
  668|       |#else
  669|      0|    reason = errno;
  670|      0|#endif
  671|      0|  }
  672|       |
  673|  2.18k|  state->top = (state->top + 1) % ERR_NUM_ERRORS;
  ------------------
  |  |  477|  2.18k|#define ERR_NUM_ERRORS 16
  ------------------
  674|  2.18k|  if (state->top == state->bottom) {
  ------------------
  |  Branch (674:7): [True: 2.17k, False: 15]
  ------------------
  675|  2.17k|    state->bottom = (state->bottom + 1) % ERR_NUM_ERRORS;
  ------------------
  |  |  477|  2.17k|#define ERR_NUM_ERRORS 16
  ------------------
  676|  2.17k|  }
  677|       |
  678|  2.18k|  error = &state->errors[state->top];
  679|  2.18k|  err_clear(error);
  680|  2.18k|  error->file = file;
  681|  2.18k|  error->line = line;
  682|  2.18k|  error->packed = ERR_PACK(library, reason);
  ------------------
  |  |  480|  2.18k|  (((((uint32_t)(lib)) & 0xff) << 24) | ((((uint32_t)(reason)) & 0xfff)))
  ------------------
  683|  2.18k|}
err.c:err_get_state:
  213|  2.18k|static ERR_STATE *err_get_state(void) {
  214|  2.18k|  ERR_STATE *state = CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_ERR);
  215|  2.18k|  if (state == NULL) {
  ------------------
  |  Branch (215:7): [True: 1, False: 2.18k]
  ------------------
  216|      1|    state = malloc(sizeof(ERR_STATE));
  217|      1|    if (state == NULL) {
  ------------------
  |  Branch (217:9): [True: 0, False: 1]
  ------------------
  218|      0|      return NULL;
  219|      0|    }
  220|      1|    OPENSSL_memset(state, 0, sizeof(ERR_STATE));
  221|      1|    if (!CRYPTO_set_thread_local(OPENSSL_THREAD_LOCAL_ERR, state,
  ------------------
  |  Branch (221:9): [True: 0, False: 1]
  ------------------
  222|      1|                                 err_state_free)) {
  223|      0|      return NULL;
  224|      0|    }
  225|      1|  }
  226|       |
  227|  2.18k|  return state;
  228|  2.18k|}
err.c:err_clear:
  168|  2.18k|static void err_clear(struct err_error_st *error) {
  169|  2.18k|  free(error->data);
  170|  2.18k|  OPENSSL_memset(error, 0, sizeof(struct err_error_st));
  171|  2.18k|}

EVP_PKEY_free:
  106|  3.18k|void EVP_PKEY_free(EVP_PKEY *pkey) {
  107|  3.18k|  if (pkey == NULL) {
  ------------------
  |  Branch (107:7): [True: 3.18k, False: 0]
  ------------------
  108|  3.18k|    return;
  109|  3.18k|  }
  110|       |
  111|      0|  if (!CRYPTO_refcount_dec_and_test_zero(&pkey->references)) {
  ------------------
  |  Branch (111:7): [True: 0, False: 0]
  ------------------
  112|      0|    return;
  113|      0|  }
  114|       |
  115|      0|  free_it(pkey);
  116|      0|  OPENSSL_free(pkey);
  117|      0|}

mem.c:OPENSSL_memset:
 1055|  5.09k|static inline void *OPENSSL_memset(void *dst, int c, size_t n) {
 1056|  5.09k|  if (n == 0) {
  ------------------
  |  Branch (1056:7): [True: 0, False: 5.09k]
  ------------------
 1057|      0|    return dst;
 1058|      0|  }
 1059|       |
 1060|  5.09k|  return memset(dst, c, n);
 1061|  5.09k|}
pkcs8_x509.c:OPENSSL_memset:
 1055|    995|static inline void *OPENSSL_memset(void *dst, int c, size_t n) {
 1056|    995|  if (n == 0) {
  ------------------
  |  Branch (1056:7): [True: 0, False: 995]
  ------------------
 1057|      0|    return dst;
 1058|      0|  }
 1059|       |
 1060|    995|  return memset(dst, c, n);
 1061|    995|}
stack.c:OPENSSL_memset:
 1055|  4.37k|static inline void *OPENSSL_memset(void *dst, int c, size_t n) {
 1056|  4.37k|  if (n == 0) {
  ------------------
  |  Branch (1056:7): [True: 0, False: 4.37k]
  ------------------
 1057|      0|    return dst;
 1058|      0|  }
 1059|       |
 1060|  4.37k|  return memset(dst, c, n);
 1061|  4.37k|}
cbb.c:OPENSSL_memset:
 1055|  95.0k|static inline void *OPENSSL_memset(void *dst, int c, size_t n) {
 1056|  95.0k|  if (n == 0) {
  ------------------
  |  Branch (1056:7): [True: 0, False: 95.0k]
  ------------------
 1057|      0|    return dst;
 1058|      0|  }
 1059|       |
 1060|  95.0k|  return memset(dst, c, n);
 1061|  95.0k|}
cbb.c:OPENSSL_memmove:
 1047|  2.17k|static inline void *OPENSSL_memmove(void *dst, const void *src, size_t n) {
 1048|  2.17k|  if (n == 0) {
  ------------------
  |  Branch (1048:7): [True: 0, False: 2.17k]
  ------------------
 1049|      0|    return dst;
 1050|      0|  }
 1051|       |
 1052|  2.17k|  return memmove(dst, src, n);
 1053|  2.17k|}
cbb.c:OPENSSL_memcpy:
 1039|  4.05k|static inline void *OPENSSL_memcpy(void *dst, const void *src, size_t n) {
 1040|  4.05k|  if (n == 0) {
  ------------------
  |  Branch (1040:7): [True: 1.01k, False: 3.04k]
  ------------------
 1041|  1.01k|    return dst;
 1042|  1.01k|  }
 1043|       |
 1044|  3.04k|  return memcpy(dst, src, n);
 1045|  4.05k|}
err.c:OPENSSL_memset:
 1055|  2.18k|static inline void *OPENSSL_memset(void *dst, int c, size_t n) {
 1056|  2.18k|  if (n == 0) {
  ------------------
  |  Branch (1056:7): [True: 0, False: 2.18k]
  ------------------
 1057|      0|    return dst;
 1058|      0|  }
 1059|       |
 1060|  2.18k|  return memset(dst, c, n);
 1061|  2.18k|}
thread_pthread.c:OPENSSL_memset:
 1055|      1|static inline void *OPENSSL_memset(void *dst, int c, size_t n) {
 1056|      1|  if (n == 0) {
  ------------------
  |  Branch (1056:7): [True: 0, False: 1]
  ------------------
 1057|      0|    return dst;
 1058|      0|  }
 1059|       |
 1060|      1|  return memset(dst, c, n);
 1061|      1|}

OPENSSL_malloc:
  228|  5.09k|void *OPENSSL_malloc(size_t size) {
  229|  5.09k|  if (should_fail_allocation()) {
  ------------------
  |  Branch (229:7): [True: 0, False: 5.09k]
  ------------------
  230|      0|    goto err;
  231|      0|  }
  232|       |
  233|  5.09k|  if (OPENSSL_memory_alloc != NULL) {
  ------------------
  |  Branch (233:7): [True: 0, False: 5.09k]
  ------------------
  234|      0|    assert(OPENSSL_memory_free != NULL);
  235|      0|    assert(OPENSSL_memory_get_size != NULL);
  236|      0|    void *ptr = OPENSSL_memory_alloc(size);
  237|      0|    if (ptr == NULL && size != 0) {
  ------------------
  |  Branch (237:9): [True: 0, False: 0]
  |  Branch (237:24): [True: 0, False: 0]
  ------------------
  238|      0|      goto err;
  239|      0|    }
  240|      0|    return ptr;
  241|      0|  }
  242|       |
  243|  5.09k|  if (size + OPENSSL_MALLOC_PREFIX < size) {
  ------------------
  |  |   83|  5.09k|#define OPENSSL_MALLOC_PREFIX 8
  ------------------
  |  Branch (243:7): [True: 0, False: 5.09k]
  ------------------
  244|       |    // |OPENSSL_malloc| is a central function in BoringSSL thus a reference to
  245|       |    // |kBoringSSLBinaryTag| is created here so that the tag isn't discarded by
  246|       |    // the linker. The following is sufficient to stop GCC, Clang, and MSVC
  247|       |    // optimising away the reference at the time of writing. Since this
  248|       |    // probably results in an actual memory reference, it is put in this very
  249|       |    // rare code path.
  250|      0|    uint8_t unused = *(volatile uint8_t *)kBoringSSLBinaryTag;
  251|      0|    (void) unused;
  252|      0|    goto err;
  253|      0|  }
  254|       |
  255|  5.09k|  void *ptr = malloc(size + OPENSSL_MALLOC_PREFIX);
  ------------------
  |  |   83|  5.09k|#define OPENSSL_MALLOC_PREFIX 8
  ------------------
  256|  5.09k|  if (ptr == NULL) {
  ------------------
  |  Branch (256:7): [True: 0, False: 5.09k]
  ------------------
  257|      0|    goto err;
  258|      0|  }
  259|       |
  260|  5.09k|  *(size_t *)ptr = size;
  261|       |
  262|  5.09k|  __asan_poison_memory_region(ptr, OPENSSL_MALLOC_PREFIX);
  ------------------
  |  |   83|  5.09k|#define OPENSSL_MALLOC_PREFIX 8
  ------------------
  263|  5.09k|  return ((uint8_t *)ptr) + OPENSSL_MALLOC_PREFIX;
  ------------------
  |  |   83|  5.09k|#define OPENSSL_MALLOC_PREFIX 8
  ------------------
  264|       |
  265|      0| err:
  266|       |  // This only works because ERR does not call OPENSSL_malloc.
  267|      0|  OPENSSL_PUT_ERROR(CRYPTO, ERR_R_MALLOC_FAILURE);
  ------------------
  |  |  441|      0|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  268|      0|  return NULL;
  269|  5.09k|}
OPENSSL_free:
  271|  6.09k|void OPENSSL_free(void *orig_ptr) {
  272|  6.09k|  if (orig_ptr == NULL) {
  ------------------
  |  Branch (272:7): [True: 995, False: 5.09k]
  ------------------
  273|    995|    return;
  274|    995|  }
  275|       |
  276|  5.09k|  if (OPENSSL_memory_free != NULL) {
  ------------------
  |  Branch (276:7): [True: 0, False: 5.09k]
  ------------------
  277|      0|    OPENSSL_memory_free(orig_ptr);
  278|      0|    return;
  279|      0|  }
  280|       |
  281|  5.09k|  void *ptr = ((uint8_t *)orig_ptr) - OPENSSL_MALLOC_PREFIX;
  ------------------
  |  |   83|  5.09k|#define OPENSSL_MALLOC_PREFIX 8
  ------------------
  282|  5.09k|  __asan_unpoison_memory_region(ptr, OPENSSL_MALLOC_PREFIX);
  ------------------
  |  |   83|  5.09k|#define OPENSSL_MALLOC_PREFIX 8
  ------------------
  283|       |
  284|  5.09k|  size_t size = *(size_t *)ptr;
  285|  5.09k|  OPENSSL_cleanse(ptr, size + OPENSSL_MALLOC_PREFIX);
  ------------------
  |  |   83|  5.09k|#define OPENSSL_MALLOC_PREFIX 8
  ------------------
  286|       |
  287|       |// ASan knows to intercept malloc and free, but not sdallocx.
  288|       |#if defined(OPENSSL_ASAN)
  289|       |  (void)sdallocx;
  290|       |  free(ptr);
  291|       |#else
  292|  5.09k|  if (sdallocx) {
  ------------------
  |  Branch (292:7): [True: 0, False: 5.09k]
  ------------------
  293|      0|    sdallocx(ptr, size + OPENSSL_MALLOC_PREFIX, 0 /* flags */);
  ------------------
  |  |   83|      0|#define OPENSSL_MALLOC_PREFIX 8
  ------------------
  294|  5.09k|  } else {
  295|  5.09k|    free(ptr);
  296|  5.09k|  }
  297|  5.09k|#endif
  298|  5.09k|}
OPENSSL_realloc:
  300|     63|void *OPENSSL_realloc(void *orig_ptr, size_t new_size) {
  301|     63|  if (orig_ptr == NULL) {
  ------------------
  |  Branch (301:7): [True: 0, False: 63]
  ------------------
  302|      0|    return OPENSSL_malloc(new_size);
  303|      0|  }
  304|       |
  305|     63|  size_t old_size;
  306|     63|  if (OPENSSL_memory_get_size != NULL) {
  ------------------
  |  Branch (306:7): [True: 0, False: 63]
  ------------------
  307|      0|    old_size = OPENSSL_memory_get_size(orig_ptr);
  308|     63|  } else {
  309|     63|    void *ptr = ((uint8_t *)orig_ptr) - OPENSSL_MALLOC_PREFIX;
  ------------------
  |  |   83|     63|#define OPENSSL_MALLOC_PREFIX 8
  ------------------
  310|     63|    __asan_unpoison_memory_region(ptr, OPENSSL_MALLOC_PREFIX);
  ------------------
  |  |   83|     63|#define OPENSSL_MALLOC_PREFIX 8
  ------------------
  311|     63|    old_size = *(size_t *)ptr;
  312|     63|    __asan_poison_memory_region(ptr, OPENSSL_MALLOC_PREFIX);
  ------------------
  |  |   83|     63|#define OPENSSL_MALLOC_PREFIX 8
  ------------------
  313|     63|  }
  314|       |
  315|     63|  void *ret = OPENSSL_malloc(new_size);
  316|     63|  if (ret == NULL) {
  ------------------
  |  Branch (316:7): [True: 0, False: 63]
  ------------------
  317|      0|    return NULL;
  318|      0|  }
  319|       |
  320|     63|  size_t to_copy = new_size;
  321|     63|  if (old_size < to_copy) {
  ------------------
  |  Branch (321:7): [True: 63, False: 0]
  ------------------
  322|     63|    to_copy = old_size;
  323|     63|  }
  324|       |
  325|     63|  memcpy(ret, orig_ptr, to_copy);
  326|     63|  OPENSSL_free(orig_ptr);
  327|       |
  328|     63|  return ret;
  329|     63|}
OPENSSL_cleanse:
  331|  5.09k|void OPENSSL_cleanse(void *ptr, size_t len) {
  332|       |#if defined(OPENSSL_WINDOWS)
  333|       |  SecureZeroMemory(ptr, len);
  334|       |#else
  335|  5.09k|  OPENSSL_memset(ptr, 0, len);
  336|       |
  337|  5.09k|#if !defined(OPENSSL_NO_ASM)
  338|       |  /* As best as we can tell, this is sufficient to break any optimisations that
  339|       |     might try to eliminate "superfluous" memsets. If there's an easy way to
  340|       |     detect memset_s, it would be better to use that. */
  341|  5.09k|  __asm__ __volatile__("" : : "r"(ptr) : "memory");
  342|  5.09k|#endif
  343|  5.09k|#endif  // !OPENSSL_NO_ASM
  344|  5.09k|}
CRYPTO_memcmp:
  360|      5|int CRYPTO_memcmp(const void *in_a, const void *in_b, size_t len) {
  361|      5|  const uint8_t *a = in_a;
  362|      5|  const uint8_t *b = in_b;
  363|      5|  uint8_t x = 0;
  364|       |
  365|     50|  for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (365:22): [True: 45, False: 5]
  ------------------
  366|     45|    x |= a[i] ^ b[i];
  367|     45|  }
  368|       |
  369|      5|  return x;
  370|      5|}
mem.c:should_fail_allocation:
  225|  5.09k|static int should_fail_allocation(void) { return 0; }
mem.c:__asan_poison_memory_region:
   90|  5.15k|static void __asan_poison_memory_region(const void *addr, size_t size) {}
mem.c:__asan_unpoison_memory_region:
   91|  5.15k|static void __asan_unpoison_memory_region(const void *addr, size_t size) {}

PKCS12_get_key_and_certs:
  587|  2.18k|                             CBS *ber_in, const char *password) {
  588|  2.18k|  uint8_t *storage = NULL;
  589|  2.18k|  CBS in, pfx, mac_data, authsafe, content_type, wrapped_authsafes, authsafes;
  590|  2.18k|  uint64_t version;
  591|  2.18k|  int ret = 0;
  592|  2.18k|  struct pkcs12_context ctx;
  593|  2.18k|  const size_t original_out_certs_len = sk_X509_num(out_certs);
  594|       |
  595|       |  // The input may be in BER format.
  596|  2.18k|  if (!CBS_asn1_ber_to_der(ber_in, &in, &storage)) {
  ------------------
  |  Branch (596:7): [True: 1.19k, False: 995]
  ------------------
  597|  1.19k|    OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_BAD_PKCS12_DATA);
  ------------------
  |  |  441|  1.19k|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  598|  1.19k|    return 0;
  599|  1.19k|  }
  600|       |
  601|    995|  *out_key = NULL;
  602|    995|  OPENSSL_memset(&ctx, 0, sizeof(ctx));
  603|       |
  604|       |  // See ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-12/pkcs-12v1.pdf, section
  605|       |  // four.
  606|    995|  if (!CBS_get_asn1(&in, &pfx, CBS_ASN1_SEQUENCE) ||
  ------------------
  |  |  222|    995|#define CBS_ASN1_SEQUENCE (0x10u | CBS_ASN1_CONSTRUCTED)
  |  |  ------------------
  |  |  |  |  196|    995|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  193|    995|#define CBS_ASN1_TAG_SHIFT 24
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (606:7): [True: 629, False: 366]
  ------------------
  607|    995|      CBS_len(&in) != 0 ||
  ------------------
  |  Branch (607:7): [True: 11, False: 355]
  ------------------
  608|    995|      !CBS_get_asn1_uint64(&pfx, &version)) {
  ------------------
  |  Branch (608:7): [True: 162, False: 193]
  ------------------
  609|    802|    OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_BAD_PKCS12_DATA);
  ------------------
  |  |  441|    802|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  610|    802|    goto err;
  611|    802|  }
  612|       |
  613|    193|  if (version < 3) {
  ------------------
  |  Branch (613:7): [True: 2, False: 191]
  ------------------
  614|      2|    OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_BAD_PKCS12_VERSION);
  ------------------
  |  |  441|      2|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  615|      2|    goto err;
  616|      2|  }
  617|       |
  618|    191|  if (!CBS_get_asn1(&pfx, &authsafe, CBS_ASN1_SEQUENCE)) {
  ------------------
  |  |  222|    191|#define CBS_ASN1_SEQUENCE (0x10u | CBS_ASN1_CONSTRUCTED)
  |  |  ------------------
  |  |  |  |  196|    191|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  193|    191|#define CBS_ASN1_TAG_SHIFT 24
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (618:7): [True: 123, False: 68]
  ------------------
  619|    123|    OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_BAD_PKCS12_DATA);
  ------------------
  |  |  441|    123|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  620|    123|    goto err;
  621|    123|  }
  622|       |
  623|     68|  if (CBS_len(&pfx) == 0) {
  ------------------
  |  Branch (623:7): [True: 1, False: 67]
  ------------------
  624|      1|    OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_MISSING_MAC);
  ------------------
  |  |  441|      1|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  625|      1|    goto err;
  626|      1|  }
  627|       |
  628|     67|  if (!CBS_get_asn1(&pfx, &mac_data, CBS_ASN1_SEQUENCE)) {
  ------------------
  |  |  222|     67|#define CBS_ASN1_SEQUENCE (0x10u | CBS_ASN1_CONSTRUCTED)
  |  |  ------------------
  |  |  |  |  196|     67|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  193|     67|#define CBS_ASN1_TAG_SHIFT 24
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (628:7): [True: 17, False: 50]
  ------------------
  629|     17|    OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_BAD_PKCS12_DATA);
  ------------------
  |  |  441|     17|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  630|     17|    goto err;
  631|     17|  }
  632|       |
  633|       |  // authsafe is a PKCS#7 ContentInfo. See
  634|       |  // https://tools.ietf.org/html/rfc2315#section-7.
  635|     50|  if (!CBS_get_asn1(&authsafe, &content_type, CBS_ASN1_OBJECT) ||
  ------------------
  |  |  219|     50|#define CBS_ASN1_OBJECT 0x6u
  ------------------
  |  Branch (635:7): [True: 4, False: 46]
  ------------------
  636|     50|      !CBS_get_asn1(&authsafe, &wrapped_authsafes,
  ------------------
  |  Branch (636:7): [True: 3, False: 43]
  ------------------
  637|     46|                        CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0)) {
  ------------------
  |  |  202|     46|#define CBS_ASN1_CONTEXT_SPECIFIC (0x80u << CBS_ASN1_TAG_SHIFT)
  |  |  ------------------
  |  |  |  |  193|     46|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
                                      CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0)) {
  ------------------
  |  |  196|     46|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  ------------------
  |  |  |  |  193|     46|#define CBS_ASN1_TAG_SHIFT 24
  |  |  ------------------
  ------------------
  638|      7|    OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_BAD_PKCS12_DATA);
  ------------------
  |  |  441|      7|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  639|      7|    goto err;
  640|      7|  }
  641|       |
  642|       |  // The content type can either be data or signedData. The latter indicates
  643|       |  // that it's signed by a public key, which isn't supported.
  644|     43|  if (!CBS_mem_equal(&content_type, kPKCS7Data, sizeof(kPKCS7Data))) {
  ------------------
  |  Branch (644:7): [True: 43, False: 0]
  ------------------
  645|     43|    OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_PKCS12_PUBLIC_KEY_INTEGRITY_NOT_SUPPORTED);
  ------------------
  |  |  441|     43|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  646|     43|    goto err;
  647|     43|  }
  648|       |
  649|      0|  if (!CBS_get_asn1(&wrapped_authsafes, &authsafes, CBS_ASN1_OCTETSTRING)) {
  ------------------
  |  |  217|      0|#define CBS_ASN1_OCTETSTRING 0x4u
  ------------------
  |  Branch (649:7): [True: 0, False: 0]
  ------------------
  650|      0|    OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_BAD_PKCS12_DATA);
  ------------------
  |  |  441|      0|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  651|      0|    goto err;
  652|      0|  }
  653|       |
  654|      0|  ctx.out_key = out_key;
  655|      0|  ctx.out_certs = out_certs;
  656|      0|  ctx.password = password;
  657|      0|  ctx.password_len = password != NULL ? strlen(password) : 0;
  ------------------
  |  Branch (657:22): [True: 0, False: 0]
  ------------------
  658|       |
  659|       |  // Verify the MAC.
  660|      0|  {
  661|      0|    CBS mac, salt, expected_mac;
  662|      0|    if (!CBS_get_asn1(&mac_data, &mac, CBS_ASN1_SEQUENCE)) {
  ------------------
  |  |  222|      0|#define CBS_ASN1_SEQUENCE (0x10u | CBS_ASN1_CONSTRUCTED)
  |  |  ------------------
  |  |  |  |  196|      0|#define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  193|      0|#define CBS_ASN1_TAG_SHIFT 24
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (662:9): [True: 0, False: 0]
  ------------------
  663|      0|      OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_BAD_PKCS12_DATA);
  ------------------
  |  |  441|      0|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  664|      0|      goto err;
  665|      0|    }
  666|       |
  667|      0|    const EVP_MD *md = EVP_parse_digest_algorithm(&mac);
  668|      0|    if (md == NULL) {
  ------------------
  |  Branch (668:9): [True: 0, False: 0]
  ------------------
  669|      0|      goto err;
  670|      0|    }
  671|       |
  672|      0|    if (!CBS_get_asn1(&mac, &expected_mac, CBS_ASN1_OCTETSTRING) ||
  ------------------
  |  |  217|      0|#define CBS_ASN1_OCTETSTRING 0x4u
  ------------------
  |  Branch (672:9): [True: 0, False: 0]
  ------------------
  673|      0|        !CBS_get_asn1(&mac_data, &salt, CBS_ASN1_OCTETSTRING)) {
  ------------------
  |  |  217|      0|#define CBS_ASN1_OCTETSTRING 0x4u
  ------------------
  |  Branch (673:9): [True: 0, False: 0]
  ------------------
  674|      0|      OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_BAD_PKCS12_DATA);
  ------------------
  |  |  441|      0|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  675|      0|      goto err;
  676|      0|    }
  677|       |
  678|       |    // The iteration count is optional and the default is one.
  679|      0|    uint64_t iterations = 1;
  680|      0|    if (CBS_len(&mac_data) > 0) {
  ------------------
  |  Branch (680:9): [True: 0, False: 0]
  ------------------
  681|      0|      if (!CBS_get_asn1_uint64(&mac_data, &iterations) ||
  ------------------
  |  Branch (681:11): [True: 0, False: 0]
  ------------------
  682|      0|          !pkcs12_iterations_acceptable(iterations)) {
  ------------------
  |  Branch (682:11): [True: 0, False: 0]
  ------------------
  683|      0|        OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_BAD_PKCS12_DATA);
  ------------------
  |  |  441|      0|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  684|      0|        goto err;
  685|      0|      }
  686|      0|    }
  687|       |
  688|      0|    int mac_ok;
  689|      0|    if (!pkcs12_check_mac(&mac_ok, ctx.password, ctx.password_len, &salt,
  ------------------
  |  Branch (689:9): [True: 0, False: 0]
  ------------------
  690|      0|                          iterations, md, &authsafes, &expected_mac)) {
  691|      0|      goto err;
  692|      0|    }
  693|      0|    if (!mac_ok && ctx.password_len == 0) {
  ------------------
  |  Branch (693:9): [True: 0, False: 0]
  |  Branch (693:20): [True: 0, False: 0]
  ------------------
  694|       |      // PKCS#12 encodes passwords as NUL-terminated UCS-2, so the empty
  695|       |      // password is encoded as {0, 0}. Some implementations use the empty byte
  696|       |      // array for "no password". OpenSSL considers a non-NULL password as {0,
  697|       |      // 0} and a NULL password as {}. It then, in high-level PKCS#12 parsing
  698|       |      // code, tries both options. We match this behavior.
  699|      0|      ctx.password = ctx.password != NULL ? NULL : "";
  ------------------
  |  Branch (699:22): [True: 0, False: 0]
  ------------------
  700|      0|      if (!pkcs12_check_mac(&mac_ok, ctx.password, ctx.password_len, &salt,
  ------------------
  |  Branch (700:11): [True: 0, False: 0]
  ------------------
  701|      0|                            iterations, md, &authsafes, &expected_mac)) {
  702|      0|        goto err;
  703|      0|      }
  704|      0|    }
  705|      0|    if (!mac_ok) {
  ------------------
  |  Branch (705:9): [True: 0, False: 0]
  ------------------
  706|      0|      OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_INCORRECT_PASSWORD);
  ------------------
  |  |  441|      0|  ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
  ------------------
  707|      0|      goto err;
  708|      0|    }
  709|      0|  }
  710|       |
  711|       |  // authsafes contains a series of PKCS#7 ContentInfos.
  712|      0|  if (!PKCS12_handle_sequence(&authsafes, &ctx, PKCS12_handle_content_info)) {
  ------------------
  |  Branch (712:7): [True: 0, False: 0]
  ------------------
  713|      0|    goto err;
  714|      0|  }
  715|       |
  716|      0|  ret = 1;
  717|       |
  718|    995|err:
  719|    995|  OPENSSL_free(storage);
  720|    995|  if (!ret) {
  ------------------
  |  Branch (720:7): [True: 995, False: 0]
  ------------------
  721|    995|    EVP_PKEY_free(*out_key);
  722|    995|    *out_key = NULL;
  723|    995|    while (sk_X509_num(out_certs) > original_out_certs_len) {
  ------------------
  |  Branch (723:12): [True: 0, False: 995]
  ------------------
  724|      0|      X509 *x509 = sk_X509_pop(out_certs);
  725|      0|      X509_free(x509);
  726|      0|    }
  727|    995|  }
  728|       |
  729|    995|  return ret;
  730|      0|}

sk_new:
   72|  2.18k|_STACK *sk_new(OPENSSL_sk_cmp_func comp) {
   73|  2.18k|  _STACK *ret = OPENSSL_malloc(sizeof(_STACK));
   74|  2.18k|  if (ret == NULL) {
  ------------------
  |  Branch (74:7): [True: 0, False: 2.18k]
  ------------------
   75|      0|    return NULL;
   76|      0|  }
   77|  2.18k|  OPENSSL_memset(ret, 0, sizeof(_STACK));
   78|       |
   79|  2.18k|  ret->data = OPENSSL_malloc(sizeof(void *) * kMinSize);
   80|  2.18k|  if (ret->data == NULL) {
  ------------------
  |  Branch (80:7): [True: 0, False: 2.18k]
  ------------------
   81|      0|    goto err;
   82|      0|  }
   83|       |
   84|  2.18k|  OPENSSL_memset(ret->data, 0, sizeof(void *) * kMinSize);
   85|       |
   86|  2.18k|  ret->comp = comp;
   87|  2.18k|  ret->num_alloc = kMinSize;
   88|       |
   89|  2.18k|  return ret;
   90|       |
   91|      0|err:
   92|      0|  OPENSSL_free(ret);
   93|      0|  return NULL;
   94|  2.18k|}
sk_new_null:
   96|  2.18k|_STACK *sk_new_null(void) { return sk_new(NULL); }
sk_num:
   98|  3.18k|size_t sk_num(const _STACK *sk) {
   99|  3.18k|  if (sk == NULL) {
  ------------------
  |  Branch (99:7): [True: 0, False: 3.18k]
  ------------------
  100|      0|    return 0;
  101|      0|  }
  102|  3.18k|  return sk->num;
  103|  3.18k|}
sk_free:
  128|  2.18k|void sk_free(_STACK *sk) {
  129|  2.18k|  if (sk == NULL) {
  ------------------
  |  Branch (129:7): [True: 0, False: 2.18k]
  ------------------
  130|      0|    return;
  131|      0|  }
  132|  2.18k|  OPENSSL_free(sk->data);
  133|  2.18k|  OPENSSL_free(sk);
  134|  2.18k|}
sk_pop_free_ex:
  137|  2.18k|                    OPENSSL_sk_free_func free_func) {
  138|  2.18k|  if (sk == NULL) {
  ------------------
  |  Branch (138:7): [True: 0, False: 2.18k]
  ------------------
  139|      0|    return;
  140|      0|  }
  141|       |
  142|  2.18k|  for (size_t i = 0; i < sk->num; i++) {
  ------------------
  |  Branch (142:22): [True: 0, False: 2.18k]
  ------------------
  143|      0|    if (sk->data[i] != NULL) {
  ------------------
  |  Branch (143:9): [True: 0, False: 0]
  ------------------
  144|      0|      call_free_func(free_func, sk->data[i]);
  145|      0|    }
  146|      0|  }
  147|  2.18k|  sk_free(sk);
  148|  2.18k|}

CRYPTO_once:
   89|  2.18k|void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void)) {
   90|  2.18k|  if (pthread_once(once, init) != 0) {
  ------------------
  |  Branch (90:7): [True: 0, False: 2.18k]
  ------------------
   91|      0|    abort();
   92|      0|  }
   93|  2.18k|}
CRYPTO_get_thread_local:
  132|  2.18k|void *CRYPTO_get_thread_local(thread_local_data_t index) {
  133|  2.18k|  CRYPTO_once(&g_thread_local_init_once, thread_local_init);
  134|  2.18k|  if (!g_thread_local_key_created) {
  ------------------
  |  Branch (134:7): [True: 0, False: 2.18k]
  ------------------
  135|      0|    return NULL;
  136|      0|  }
  137|       |
  138|  2.18k|  void **pointers = pthread_getspecific(g_thread_local_key);
  139|  2.18k|  if (pointers == NULL) {
  ------------------
  |  Branch (139:7): [True: 1, False: 2.18k]
  ------------------
  140|      1|    return NULL;
  141|      1|  }
  142|  2.18k|  return pointers[index];
  143|  2.18k|}
CRYPTO_set_thread_local:
  146|      1|                            thread_local_destructor_t destructor) {
  147|      1|  CRYPTO_once(&g_thread_local_init_once, thread_local_init);
  148|      1|  if (!g_thread_local_key_created) {
  ------------------
  |  Branch (148:7): [True: 0, False: 1]
  ------------------
  149|      0|    destructor(value);
  150|      0|    return 0;
  151|      0|  }
  152|       |
  153|      1|  void **pointers = pthread_getspecific(g_thread_local_key);
  154|      1|  if (pointers == NULL) {
  ------------------
  |  Branch (154:7): [True: 1, False: 0]
  ------------------
  155|      1|    pointers = malloc(sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
  156|      1|    if (pointers == NULL) {
  ------------------
  |  Branch (156:9): [True: 0, False: 1]
  ------------------
  157|      0|      destructor(value);
  158|      0|      return 0;
  159|      0|    }
  160|      1|    OPENSSL_memset(pointers, 0, sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
  161|      1|    if (pthread_setspecific(g_thread_local_key, pointers) != 0) {
  ------------------
  |  Branch (161:9): [True: 0, False: 1]
  ------------------
  162|      0|      free(pointers);
  163|      0|      destructor(value);
  164|      0|      return 0;
  165|      0|    }
  166|      1|  }
  167|       |
  168|      1|  if (pthread_mutex_lock(&g_destructors_lock) != 0) {
  ------------------
  |  Branch (168:7): [True: 0, False: 1]
  ------------------
  169|      0|    destructor(value);
  170|      0|    return 0;
  171|      0|  }
  172|      1|  g_destructors[index] = destructor;
  173|      1|  pthread_mutex_unlock(&g_destructors_lock);
  174|       |
  175|      1|  pointers[index] = value;
  176|      1|  return 1;
  177|      1|}
thread_pthread.c:thread_local_init:
  127|      1|static void thread_local_init(void) {
  128|      1|  g_thread_local_key_created =
  129|      1|      pthread_key_create(&g_thread_local_key, thread_local_destructor) == 0;
  130|      1|}

_ZN4bssl8internal7DeleterclI13stack_st_X509EEvPT_:
  560|  2.18k|  void operator()(T *ptr) {
  561|       |    // Rather than specialize Deleter for each type, we specialize
  562|       |    // DeleterImpl. This allows bssl::UniquePtr<T> to be used while only
  563|       |    // including base.h as long as the destructor is not emitted. This matches
  564|       |    // std::unique_ptr's behavior on forward-declared types.
  565|       |    //
  566|       |    // DeleterImpl itself is specialized in the corresponding module's header
  567|       |    // and must be included to release an object. If not included, the compiler
  568|       |    // will error that DeleterImpl<T> does not have a method Free.
  569|  2.18k|    DeleterImpl<T>::Free(ptr);
  570|  2.18k|  }

sk_X509_new_null:
  420|  2.18k|  OPENSSL_INLINE STACK_OF(name) *sk_##name##_new_null(void) {                 \
  421|  2.18k|    return (STACK_OF(name) *)sk_new_null();                                   \
  422|  2.18k|  }                                                                           \
_ZN4bssl8internal11DeleterImplI13stack_st_X509vE4FreeEPS2_:
  552|  2.18k|  static void Free(Stack *sk) {
  553|       |    // sk_FOO_pop_free is defined by macros and bound by name, so we cannot
  554|       |    // access it from C++ here.
  555|  2.18k|    using Type = typename StackTraits<Stack>::Type;
  556|  2.18k|    sk_pop_free_ex(reinterpret_cast<_STACK *>(sk),
  557|  2.18k|                   [](OPENSSL_sk_free_func /* unused */, void *ptr) {
  558|  2.18k|                     DeleterImpl<Type>::Free(reinterpret_cast<Type *>(ptr));
  559|  2.18k|                   },
  560|  2.18k|                   nullptr);
  561|  2.18k|  }
pkcs8_x509.c:sk_X509_num:
  424|  3.18k|  OPENSSL_INLINE size_t sk_##name##_num(const STACK_OF(name) *sk) {           \
  425|  3.18k|    return sk_num((const _STACK *)sk);                                        \
  426|  3.18k|  }                                                                           \

_Z17GetVariableIntLenmm:
   22|  8.75k|uint8_t GetVariableIntLen(uint64_t value, size_t base) {
   23|  8.75k|  uint8_t base_bits = log2(base);
   24|  66.3k|  for (uint8_t num_bits = (sizeof(value) - 1) * CHAR_BIT; num_bits >= base_bits;
  ------------------
  |  Branch (24:59): [True: 60.1k, False: 6.21k]
  ------------------
   25|  60.1k|       num_bits -= base_bits) {
   26|  60.1k|    if (value >> num_bits) {
  ------------------
  |  Branch (26:9): [True: 2.53k, False: 57.6k]
  ------------------
   27|  2.53k|      return ceil(static_cast<double>(num_bits) / base_bits) + 1;
   28|  2.53k|    }
   29|  60.1k|  }
   30|       |  // Special-case: zero requires one, not zero bytes.
   31|  6.21k|  return 1;
   32|  8.75k|}
_Z24InsertVariableIntBase128mmRNSt3__16vectorIhNS_9allocatorIhEEEE:
   36|  1.40k|                              std::vector<uint8_t>& der) {
   37|  1.40k|  std::vector<uint8_t> variable_int;
   38|  4.57k|  for (uint8_t i = GetVariableIntLen(value, 128) - 1; i != 0; --i) {
  ------------------
  |  Branch (38:55): [True: 3.17k, False: 1.40k]
  ------------------
   39|       |    // If it's not the last byte, the high bit is set to 1.
   40|  3.17k|    variable_int.push_back((0x01 << 7) | ((value >> (i * 7)) & 0x7F));
   41|  3.17k|  }
   42|  1.40k|  variable_int.push_back(value & 0x7F);
   43|  1.40k|  der.insert(der.begin() + pos, variable_int.begin(), variable_int.end());
   44|  1.40k|}
_Z24InsertVariableIntBase256mmRNSt3__16vectorIhNS_9allocatorIhEEEE:
   48|  6.06k|                              std::vector<uint8_t>& der) {
   49|  6.06k|  std::vector<uint8_t> variable_int;
   50|  13.0k|  for (uint8_t shift = GetVariableIntLen(value, 256); shift != 0; --shift) {
  ------------------
  |  Branch (50:55): [True: 6.99k, False: 6.06k]
  ------------------
   51|  6.99k|    variable_int.push_back((value >> ((shift - 1) * CHAR_BIT)) & 0xFF);
   52|  6.99k|  }
   53|  6.06k|  der.insert(der.begin() + pos, variable_int.begin(), variable_int.end());
   54|  6.06k|}

fuzz_pkcs12.cc:_ZL17TestOneProtoInputRKN8asn1_pdu3PDUE:
   29|  2.18k|DEFINE_PROTO_FUZZER(const asn1_pdu::PDU& asn1) {
   30|  2.18k|  asn1_pdu::ASN1PDUToDER converter;
   31|  2.18k|  std::vector<uint8_t> encoded = converter.PDUToDER(asn1);
   32|  2.18k|  const uint8_t* buf = encoded.data();
   33|  2.18k|  size_t len = encoded.size();
   34|       |
   35|  2.18k|  bssl::UniquePtr<STACK_OF(X509)> certs(sk_X509_new_null());
   36|  2.18k|  EVP_PKEY* key = nullptr;
   37|  2.18k|  CBS cbs;
   38|  2.18k|  CBS_init(&cbs, buf, len);
   39|  2.18k|  PKCS12_get_key_and_certs(&key, certs.get(), &cbs, "foo");
   40|  2.18k|  EVP_PKEY_free(key);
   41|  2.18k|}

_Z42descriptor_table_asn1_5fpdu_2eproto_getterv:
  280|      1|PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_asn1_5fpdu_2eproto_getter() {
  281|      1|  return &descriptor_table_asn1_5fpdu_2eproto;
  282|      1|}
_ZN8asn1_pdu3PDUC2EPN6google8protobuf5ArenaE:
  394|  12.7k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  395|  12.7k|  SharedCtor(arena);
  396|       |  // @@protoc_insertion_point(arena_constructor:asn1_pdu.PDU)
  397|  12.7k|}
_ZN8asn1_pdu3PDUD2Ev:
  432|  12.7k|PDU::~PDU() {
  433|       |  // @@protoc_insertion_point(destructor:asn1_pdu.PDU)
  434|  12.7k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (434:13): [True: 0, False: 12.7k]
  ------------------
  435|      0|  (void)arena;
  436|      0|    return;
  437|      0|  }
  438|  12.7k|  SharedDtor();
  439|  12.7k|}
_ZN8asn1_pdu3PDU5ClearEv:
  452|  9.05k|void PDU::Clear() {
  453|       |// @@protoc_insertion_point(message_clear_start:asn1_pdu.PDU)
  454|  9.05k|  ::uint32_t cached_has_bits = 0;
  455|       |  // Prevent compiler warnings about cached_has_bits being unused
  456|  9.05k|  (void) cached_has_bits;
  457|       |
  458|  9.05k|  cached_has_bits = _impl_._has_bits_[0];
  459|  9.05k|  if (cached_has_bits & 0x00000007u) {
  ------------------
  |  Branch (459:7): [True: 2.90k, False: 6.14k]
  ------------------
  460|  2.90k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (460:9): [True: 2.17k, False: 726]
  ------------------
  461|  2.17k|      ABSL_DCHECK(_impl_.id_ != nullptr);
  ------------------
  |  |   43|  2.17k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  2.17k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  2.17k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  2.17k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  2.17k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  2.17k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  462|  2.17k|      _impl_.id_->Clear();
  463|  2.17k|    }
  464|  2.90k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (464:9): [True: 1.31k, False: 1.58k]
  ------------------
  465|  1.31k|      ABSL_DCHECK(_impl_.len_ != nullptr);
  ------------------
  |  |   43|  1.31k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  1.31k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  1.31k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  1.31k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  1.31k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  1.31k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  466|  1.31k|      _impl_.len_->Clear();
  467|  1.31k|    }
  468|  2.90k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (468:9): [True: 1.74k, False: 1.15k]
  ------------------
  469|  1.74k|      ABSL_DCHECK(_impl_.val_ != nullptr);
  ------------------
  |  |   43|  1.74k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  1.74k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  1.74k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  1.74k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  1.74k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  1.74k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  470|  1.74k|      _impl_.val_->Clear();
  471|  1.74k|    }
  472|  2.90k|  }
  473|  9.05k|  _impl_._has_bits_.Clear();
  474|  9.05k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  475|  9.05k|}
_ZNK8asn1_pdu3PDU11GetMetadataEv:
  691|   142k|::PROTOBUF_NAMESPACE_ID::Metadata PDU::GetMetadata() const {
  692|   142k|  return ::_pbi::AssignDescriptors(
  693|   142k|      &descriptor_table_asn1_5fpdu_2eproto_getter, &descriptor_table_asn1_5fpdu_2eproto_once,
  694|   142k|      file_level_metadata_asn1_5fpdu_2eproto[0]);
  695|   142k|}
_ZN8asn1_pdu10IdentifierC2EPN6google8protobuf5ArenaE:
  723|  12.7k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  724|  12.7k|  SharedCtor(arena);
  725|       |  // @@protoc_insertion_point(arena_constructor:asn1_pdu.Identifier)
  726|  12.7k|}
_ZN8asn1_pdu10IdentifierD2Ev:
  762|  12.7k|Identifier::~Identifier() {
  763|       |  // @@protoc_insertion_point(destructor:asn1_pdu.Identifier)
  764|  12.7k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (764:13): [True: 0, False: 12.7k]
  ------------------
  765|      0|  (void)arena;
  766|      0|    return;
  767|      0|  }
  768|  12.7k|  SharedDtor();
  769|  12.7k|}
_ZN8asn1_pdu10Identifier5ClearEv:
  780|  6.29k|void Identifier::Clear() {
  781|       |// @@protoc_insertion_point(message_clear_start:asn1_pdu.Identifier)
  782|  6.29k|  ::uint32_t cached_has_bits = 0;
  783|       |  // Prevent compiler warnings about cached_has_bits being unused
  784|  6.29k|  (void) cached_has_bits;
  785|       |
  786|  6.29k|  cached_has_bits = _impl_._has_bits_[0];
  787|  6.29k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (787:7): [True: 1.40k, False: 4.89k]
  ------------------
  788|  1.40k|    ABSL_DCHECK(_impl_.tag_num_ != nullptr);
  ------------------
  |  |   43|  1.40k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  1.40k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  1.40k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  1.40k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  1.40k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  1.40k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  789|  1.40k|    _impl_.tag_num_->Clear();
  790|  1.40k|  }
  791|  6.29k|  if (cached_has_bits & 0x00000006u) {
  ------------------
  |  Branch (791:7): [True: 600, False: 5.69k]
  ------------------
  792|    600|    ::memset(&_impl_.encoding_, 0, static_cast<::size_t>(
  793|    600|        reinterpret_cast<char*>(&_impl_.id_class_) -
  794|    600|        reinterpret_cast<char*>(&_impl_.encoding_)) + sizeof(_impl_.id_class_));
  795|    600|  }
  796|  6.29k|  _impl_._has_bits_.Clear();
  797|  6.29k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  798|  6.29k|}
_ZNK8asn1_pdu10Identifier12GetClassDataEv:
  961|  6.17k|const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Identifier::GetClassData() const { return &_class_data_; }
_ZN8asn1_pdu10Identifier9MergeImplERN6google8protobuf7MessageERKS3_:
  964|  2.05k|void Identifier::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  965|  2.05k|  auto* const _this = static_cast<Identifier*>(&to_msg);
  966|  2.05k|  auto& from = static_cast<const Identifier&>(from_msg);
  967|       |  // @@protoc_insertion_point(class_specific_merge_from_start:asn1_pdu.Identifier)
  968|  2.05k|  ABSL_DCHECK_NE(&from, _this);
  ------------------
  |  |   72|  2.05k|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|  2.05k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  2.05k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  2.05k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  969|  2.05k|  ::uint32_t cached_has_bits = 0;
  970|  2.05k|  (void) cached_has_bits;
  971|       |
  972|  2.05k|  cached_has_bits = from._impl_._has_bits_[0];
  973|  2.05k|  if (cached_has_bits & 0x00000007u) {
  ------------------
  |  Branch (973:7): [True: 0, False: 2.05k]
  ------------------
  974|      0|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (974:9): [True: 0, False: 0]
  ------------------
  975|      0|      _this->_internal_mutable_tag_num()->::asn1_pdu::TagNumber::MergeFrom(
  976|      0|          from._internal_tag_num());
  977|      0|    }
  978|      0|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (978:9): [True: 0, False: 0]
  ------------------
  979|      0|      _this->_impl_.encoding_ = from._impl_.encoding_;
  980|      0|    }
  981|      0|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (981:9): [True: 0, False: 0]
  ------------------
  982|      0|      _this->_impl_.id_class_ = from._impl_.id_class_;
  983|      0|    }
  984|      0|    _this->_impl_._has_bits_[0] |= cached_has_bits;
  985|      0|  }
  986|  2.05k|  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  987|  2.05k|}
_ZNK8asn1_pdu10Identifier11GetMetadataEv:
 1016|   115k|::PROTOBUF_NAMESPACE_ID::Metadata Identifier::GetMetadata() const {
 1017|   115k|  return ::_pbi::AssignDescriptors(
 1018|   115k|      &descriptor_table_asn1_5fpdu_2eproto_getter, &descriptor_table_asn1_5fpdu_2eproto_once,
 1019|   115k|      file_level_metadata_asn1_5fpdu_2eproto[1]);
 1020|   115k|}
_ZN8asn1_pdu9TagNumberC2EPN6google8protobuf5ArenaE:
 1040|  12.4k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 1041|  12.4k|  SharedCtor(arena);
 1042|       |  // @@protoc_insertion_point(arena_constructor:asn1_pdu.TagNumber)
 1043|  12.4k|}
_ZN8asn1_pdu9TagNumberD2Ev:
 1063|  12.4k|TagNumber::~TagNumber() {
 1064|       |  // @@protoc_insertion_point(destructor:asn1_pdu.TagNumber)
 1065|  12.4k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (1065:13): [True: 0, False: 12.4k]
  ------------------
 1066|      0|  (void)arena;
 1067|      0|    return;
 1068|      0|  }
 1069|  12.4k|  SharedDtor();
 1070|  12.4k|}
_ZN8asn1_pdu9TagNumber5ClearEv:
 1080|  6.57k|void TagNumber::Clear() {
 1081|       |// @@protoc_insertion_point(message_clear_start:asn1_pdu.TagNumber)
 1082|  6.57k|  ::uint32_t cached_has_bits = 0;
 1083|       |  // Prevent compiler warnings about cached_has_bits being unused
 1084|  6.57k|  (void) cached_has_bits;
 1085|       |
 1086|  6.57k|  cached_has_bits = _impl_._has_bits_[0];
 1087|  6.57k|  if (cached_has_bits & 0x00000003u) {
  ------------------
  |  Branch (1087:7): [True: 954, False: 5.61k]
  ------------------
 1088|    954|    ::memset(&_impl_.high_tag_num_, 0, static_cast<::size_t>(
 1089|    954|        reinterpret_cast<char*>(&_impl_.low_tag_num_) -
 1090|    954|        reinterpret_cast<char*>(&_impl_.high_tag_num_)) + sizeof(_impl_.low_tag_num_));
 1091|    954|  }
 1092|  6.57k|  _impl_._has_bits_.Clear();
 1093|  6.57k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 1094|  6.57k|}
_ZNK8asn1_pdu9TagNumber12GetClassDataEv:
 1207|  7.75k|const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TagNumber::GetClassData() const { return &_class_data_; }
_ZN8asn1_pdu9TagNumber9MergeImplERN6google8protobuf7MessageERKS3_:
 1210|  2.58k|void TagNumber::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
 1211|  2.58k|  auto* const _this = static_cast<TagNumber*>(&to_msg);
 1212|  2.58k|  auto& from = static_cast<const TagNumber&>(from_msg);
 1213|       |  // @@protoc_insertion_point(class_specific_merge_from_start:asn1_pdu.TagNumber)
 1214|  2.58k|  ABSL_DCHECK_NE(&from, _this);
  ------------------
  |  |   72|  2.58k|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|  2.58k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  2.58k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  2.58k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1215|  2.58k|  ::uint32_t cached_has_bits = 0;
 1216|  2.58k|  (void) cached_has_bits;
 1217|       |
 1218|  2.58k|  cached_has_bits = from._impl_._has_bits_[0];
 1219|  2.58k|  if (cached_has_bits & 0x00000003u) {
  ------------------
  |  Branch (1219:7): [True: 0, False: 2.58k]
  ------------------
 1220|      0|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1220:9): [True: 0, False: 0]
  ------------------
 1221|      0|      _this->_impl_.high_tag_num_ = from._impl_.high_tag_num_;
 1222|      0|    }
 1223|      0|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1223:9): [True: 0, False: 0]
  ------------------
 1224|      0|      _this->_impl_.low_tag_num_ = from._impl_.low_tag_num_;
 1225|      0|    }
 1226|      0|    _this->_impl_._has_bits_[0] |= cached_has_bits;
 1227|      0|  }
 1228|  2.58k|  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 1229|  2.58k|}
_ZNK8asn1_pdu9TagNumber11GetMetadataEv:
 1255|  70.9k|::PROTOBUF_NAMESPACE_ID::Metadata TagNumber::GetMetadata() const {
 1256|  70.9k|  return ::_pbi::AssignDescriptors(
 1257|  70.9k|      &descriptor_table_asn1_5fpdu_2eproto_getter, &descriptor_table_asn1_5fpdu_2eproto_once,
 1258|  70.9k|      file_level_metadata_asn1_5fpdu_2eproto[2]);
 1259|  70.9k|}
_ZN8asn1_pdu6LengthC2EPN6google8protobuf5ArenaE:
 1269|  12.4k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 1270|  12.4k|  SharedCtor(arena);
 1271|       |  // @@protoc_insertion_point(arena_constructor:asn1_pdu.Length)
 1272|  12.4k|}
_ZN8asn1_pdu6LengthD2Ev:
 1309|  12.4k|Length::~Length() {
 1310|       |  // @@protoc_insertion_point(destructor:asn1_pdu.Length)
 1311|  12.4k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (1311:13): [True: 0, False: 12.4k]
  ------------------
 1312|      0|  (void)arena;
 1313|      0|    return;
 1314|      0|  }
 1315|  12.4k|  SharedDtor();
 1316|  12.4k|}
_ZN8asn1_pdu6Length11clear_typesEv:
 1329|  9.24k|void Length::clear_types() {
 1330|       |// @@protoc_insertion_point(one_of_clear_start:asn1_pdu.Length)
 1331|  9.24k|  switch (types_case()) {
  ------------------
  |  Branch (1331:11): [True: 0, False: 9.24k]
  ------------------
 1332|    881|    case kIndefiniteForm: {
  ------------------
  |  Branch (1332:5): [True: 881, False: 8.36k]
  ------------------
 1333|       |      // No need to clear
 1334|    881|      break;
 1335|      0|    }
 1336|  1.99k|    case kLengthOverride: {
  ------------------
  |  Branch (1336:5): [True: 1.99k, False: 7.25k]
  ------------------
 1337|  1.99k|      _impl_.types_.length_override_.Destroy();
 1338|  1.99k|      break;
 1339|      0|    }
 1340|  6.37k|    case TYPES_NOT_SET: {
  ------------------
  |  Branch (1340:5): [True: 6.37k, False: 2.87k]
  ------------------
 1341|  6.37k|      break;
 1342|      0|    }
 1343|  9.24k|  }
 1344|  9.24k|  _impl_._oneof_case_[0] = TYPES_NOT_SET;
 1345|  9.24k|}
_ZN8asn1_pdu6Length5ClearEv:
 1348|  6.62k|void Length::Clear() {
 1349|       |// @@protoc_insertion_point(message_clear_start:asn1_pdu.Length)
 1350|  6.62k|  ::uint32_t cached_has_bits = 0;
 1351|       |  // Prevent compiler warnings about cached_has_bits being unused
 1352|  6.62k|  (void) cached_has_bits;
 1353|       |
 1354|  6.62k|  clear_types();
 1355|  6.62k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 1356|  6.62k|}
_ZNK8asn1_pdu6Length12GetClassDataEv:
 1465|  7.96k|const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Length::GetClassData() const { return &_class_data_; }
_ZN8asn1_pdu6Length9MergeImplERN6google8protobuf7MessageERKS3_:
 1468|  2.65k|void Length::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
 1469|  2.65k|  auto* const _this = static_cast<Length*>(&to_msg);
 1470|  2.65k|  auto& from = static_cast<const Length&>(from_msg);
 1471|       |  // @@protoc_insertion_point(class_specific_merge_from_start:asn1_pdu.Length)
 1472|  2.65k|  ABSL_DCHECK_NE(&from, _this);
  ------------------
  |  |   72|  2.65k|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|  2.65k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  2.65k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  2.65k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1473|  2.65k|  ::uint32_t cached_has_bits = 0;
 1474|  2.65k|  (void) cached_has_bits;
 1475|       |
 1476|  2.65k|  switch (from.types_case()) {
  ------------------
  |  Branch (1476:11): [True: 0, False: 2.65k]
  ------------------
 1477|      0|    case kIndefiniteForm: {
  ------------------
  |  Branch (1477:5): [True: 0, False: 2.65k]
  ------------------
 1478|      0|      _this->_internal_set_indefinite_form(from._internal_indefinite_form());
 1479|      0|      break;
 1480|      0|    }
 1481|      0|    case kLengthOverride: {
  ------------------
  |  Branch (1481:5): [True: 0, False: 2.65k]
  ------------------
 1482|      0|      _this->_internal_set_length_override(from._internal_length_override());
 1483|      0|      break;
 1484|      0|    }
 1485|  2.65k|    case TYPES_NOT_SET: {
  ------------------
  |  Branch (1485:5): [True: 2.65k, False: 0]
  ------------------
 1486|  2.65k|      break;
 1487|      0|    }
 1488|  2.65k|  }
 1489|  2.65k|  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 1490|  2.65k|}
_ZNK8asn1_pdu6Length11GetMetadataEv:
 1510|  53.5k|::PROTOBUF_NAMESPACE_ID::Metadata Length::GetMetadata() const {
 1511|  53.5k|  return ::_pbi::AssignDescriptors(
 1512|  53.5k|      &descriptor_table_asn1_5fpdu_2eproto_getter, &descriptor_table_asn1_5fpdu_2eproto_once,
 1513|  53.5k|      file_level_metadata_asn1_5fpdu_2eproto[3]);
 1514|  53.5k|}
_ZN8asn1_pdu12ValueElementC2EPN6google8protobuf5ArenaE:
 1539|  15.3k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 1540|  15.3k|  SharedCtor(arena);
 1541|       |  // @@protoc_insertion_point(arena_constructor:asn1_pdu.ValueElement)
 1542|  15.3k|}
_ZN8asn1_pdu12ValueElementD2Ev:
 1582|  15.3k|ValueElement::~ValueElement() {
 1583|       |  // @@protoc_insertion_point(destructor:asn1_pdu.ValueElement)
 1584|  15.3k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (1584:13): [True: 0, False: 15.3k]
  ------------------
 1585|      0|  (void)arena;
 1586|      0|    return;
 1587|      0|  }
 1588|  15.3k|  SharedDtor();
 1589|  15.3k|}
_ZN8asn1_pdu12ValueElement5ClearEv:
 1601|  5.76k|void ValueElement::Clear() {
 1602|       |// @@protoc_insertion_point(message_clear_start:asn1_pdu.ValueElement)
 1603|  5.76k|  ::uint32_t cached_has_bits = 0;
 1604|       |  // Prevent compiler warnings about cached_has_bits being unused
 1605|  5.76k|  (void) cached_has_bits;
 1606|       |
 1607|  5.76k|  cached_has_bits = _impl_._has_bits_[0];
 1608|  5.76k|  if (cached_has_bits & 0x00000003u) {
  ------------------
  |  Branch (1608:7): [True: 5.35k, False: 409]
  ------------------
 1609|  5.35k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1609:9): [True: 1.77k, False: 3.57k]
  ------------------
 1610|  1.77k|      _impl_.val_bits_.ClearNonDefaultToEmpty();
 1611|  1.77k|    }
 1612|  5.35k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1612:9): [True: 4.10k, False: 1.24k]
  ------------------
 1613|  4.10k|      ABSL_DCHECK(_impl_.pdu_ != nullptr);
  ------------------
  |  |   43|  4.10k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  4.10k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  4.10k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  4.10k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  4.10k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  4.10k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1614|  4.10k|      _impl_.pdu_->Clear();
 1615|  4.10k|    }
 1616|  5.35k|  }
 1617|  5.76k|  _impl_._has_bits_.Clear();
 1618|  5.76k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 1619|  5.76k|}
_ZNK8asn1_pdu12ValueElement11GetMetadataEv:
 1777|   117k|::PROTOBUF_NAMESPACE_ID::Metadata ValueElement::GetMetadata() const {
 1778|   117k|  return ::_pbi::AssignDescriptors(
 1779|   117k|      &descriptor_table_asn1_5fpdu_2eproto_getter, &descriptor_table_asn1_5fpdu_2eproto_once,
 1780|   117k|      file_level_metadata_asn1_5fpdu_2eproto[4]);
 1781|   117k|}
_ZN8asn1_pdu5ValueC2EPN6google8protobuf5ArenaE:
 1789|  12.5k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 1790|  12.5k|  SharedCtor(arena);
 1791|       |  // @@protoc_insertion_point(arena_constructor:asn1_pdu.Value)
 1792|  12.5k|}
_ZN8asn1_pdu5ValueD2Ev:
 1812|  12.5k|Value::~Value() {
 1813|       |  // @@protoc_insertion_point(destructor:asn1_pdu.Value)
 1814|  12.5k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (1814:13): [True: 0, False: 12.5k]
  ------------------
 1815|      0|  (void)arena;
 1816|      0|    return;
 1817|      0|  }
 1818|  12.5k|  SharedDtor();
 1819|  12.5k|}
_ZN8asn1_pdu5Value5ClearEv:
 1830|  6.29k|void Value::Clear() {
 1831|       |// @@protoc_insertion_point(message_clear_start:asn1_pdu.Value)
 1832|  6.29k|  ::uint32_t cached_has_bits = 0;
 1833|       |  // Prevent compiler warnings about cached_has_bits being unused
 1834|  6.29k|  (void) cached_has_bits;
 1835|       |
 1836|  6.29k|  _impl_.val_array_.Clear();
 1837|  6.29k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 1838|  6.29k|}
_ZNK8asn1_pdu5Value12GetClassDataEv:
 1927|  6.81k|const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Value::GetClassData() const { return &_class_data_; }
_ZN8asn1_pdu5Value9MergeImplERN6google8protobuf7MessageERKS3_:
 1930|  2.27k|void Value::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
 1931|  2.27k|  auto* const _this = static_cast<Value*>(&to_msg);
 1932|  2.27k|  auto& from = static_cast<const Value&>(from_msg);
 1933|       |  // @@protoc_insertion_point(class_specific_merge_from_start:asn1_pdu.Value)
 1934|  2.27k|  ABSL_DCHECK_NE(&from, _this);
  ------------------
  |  |   72|  2.27k|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|  2.27k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  2.27k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  2.27k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1935|  2.27k|  ::uint32_t cached_has_bits = 0;
 1936|  2.27k|  (void) cached_has_bits;
 1937|       |
 1938|  2.27k|  _this->_impl_.val_array_.MergeFrom(from._impl_.val_array_);
 1939|  2.27k|  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 1940|  2.27k|}
_ZNK8asn1_pdu5Value11GetMetadataEv:
 1961|  92.6k|::PROTOBUF_NAMESPACE_ID::Metadata Value::GetMetadata() const {
 1962|  92.6k|  return ::_pbi::AssignDescriptors(
 1963|  92.6k|      &descriptor_table_asn1_5fpdu_2eproto_getter, &descriptor_table_asn1_5fpdu_2eproto_once,
 1964|  92.6k|      file_level_metadata_asn1_5fpdu_2eproto[5]);
 1965|  92.6k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN8asn1_pdu3PDUEJEEEPT_PS1_DpOT0_:
 1970|  10.4k|Arena::CreateMaybeMessage< ::asn1_pdu::PDU >(Arena* arena) {
 1971|  10.4k|  return Arena::CreateMessageInternal< ::asn1_pdu::PDU >(arena);
 1972|  10.4k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN8asn1_pdu10IdentifierEJEEEPT_PS1_DpOT0_:
 1974|  12.7k|Arena::CreateMaybeMessage< ::asn1_pdu::Identifier >(Arena* arena) {
 1975|  12.7k|  return Arena::CreateMessageInternal< ::asn1_pdu::Identifier >(arena);
 1976|  12.7k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN8asn1_pdu9TagNumberEJEEEPT_PS1_DpOT0_:
 1978|  12.4k|Arena::CreateMaybeMessage< ::asn1_pdu::TagNumber >(Arena* arena) {
 1979|  12.4k|  return Arena::CreateMessageInternal< ::asn1_pdu::TagNumber >(arena);
 1980|  12.4k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN8asn1_pdu6LengthEJEEEPT_PS1_DpOT0_:
 1982|  12.4k|Arena::CreateMaybeMessage< ::asn1_pdu::Length >(Arena* arena) {
 1983|  12.4k|  return Arena::CreateMessageInternal< ::asn1_pdu::Length >(arena);
 1984|  12.4k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN8asn1_pdu12ValueElementEJEEEPT_PS1_DpOT0_:
 1986|  15.3k|Arena::CreateMaybeMessage< ::asn1_pdu::ValueElement >(Arena* arena) {
 1987|  15.3k|  return Arena::CreateMessageInternal< ::asn1_pdu::ValueElement >(arena);
 1988|  15.3k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN8asn1_pdu5ValueEJEEEPT_PS1_DpOT0_:
 1990|  12.5k|Arena::CreateMaybeMessage< ::asn1_pdu::Value >(Arena* arena) {
 1991|  12.5k|  return Arena::CreateMessageInternal< ::asn1_pdu::Value >(arena);
 1992|  12.5k|}
_ZN8asn1_pdu3PDU10SharedCtorEPN6google8protobuf5ArenaE:
  421|  12.7k|inline void PDU::SharedCtor(::_pb::Arena* arena) {
  422|  12.7k|  (void)arena;
  423|  12.7k|  new (&_impl_) Impl_{
  424|  12.7k|      decltype(_impl_._has_bits_){}
  425|  12.7k|    , /*decltype(_impl_._cached_size_)*/{}
  426|  12.7k|    , decltype(_impl_.id_){nullptr}
  427|  12.7k|    , decltype(_impl_.len_){nullptr}
  428|  12.7k|    , decltype(_impl_.val_){nullptr}
  429|  12.7k|  };
  430|  12.7k|}
_ZN8asn1_pdu3PDU10SharedDtorEv:
  441|  12.7k|inline void PDU::SharedDtor() {
  442|  12.7k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  12.7k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  12.7k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  12.7k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  12.7k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  12.7k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  12.7k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  443|  12.7k|  if (this != internal_default_instance()) delete _impl_.id_;
  ------------------
  |  Branch (443:7): [True: 12.7k, False: 0]
  ------------------
  444|  12.7k|  if (this != internal_default_instance()) delete _impl_.len_;
  ------------------
  |  Branch (444:7): [True: 12.7k, False: 0]
  ------------------
  445|  12.7k|  if (this != internal_default_instance()) delete _impl_.val_;
  ------------------
  |  Branch (445:7): [True: 12.7k, False: 0]
  ------------------
  446|  12.7k|}
_ZN8asn1_pdu10Identifier10SharedCtorEPN6google8protobuf5ArenaE:
  749|  12.7k|inline void Identifier::SharedCtor(::_pb::Arena* arena) {
  750|  12.7k|  (void)arena;
  751|  12.7k|  new (&_impl_) Impl_{
  752|  12.7k|      decltype(_impl_._has_bits_){}
  753|  12.7k|    , /*decltype(_impl_._cached_size_)*/{}
  754|  12.7k|    , decltype(_impl_.tag_num_){nullptr}
  755|  12.7k|    , decltype(_impl_.encoding_) { 0 }
  756|       |
  757|  12.7k|    , decltype(_impl_.id_class_) { 0 }
  758|       |
  759|  12.7k|  };
  760|  12.7k|}
_ZN8asn1_pdu10Identifier10SharedDtorEv:
  771|  12.7k|inline void Identifier::SharedDtor() {
  772|  12.7k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  12.7k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  12.7k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  12.7k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  12.7k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  12.7k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  12.7k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  773|  12.7k|  if (this != internal_default_instance()) delete _impl_.tag_num_;
  ------------------
  |  Branch (773:7): [True: 12.7k, False: 0]
  ------------------
  774|  12.7k|}
_ZN8asn1_pdu9TagNumber10SharedCtorEPN6google8protobuf5ArenaE:
 1051|  12.4k|inline void TagNumber::SharedCtor(::_pb::Arena* arena) {
 1052|  12.4k|  (void)arena;
 1053|  12.4k|  new (&_impl_) Impl_{
 1054|  12.4k|      decltype(_impl_._has_bits_){}
 1055|  12.4k|    , /*decltype(_impl_._cached_size_)*/{}
 1056|  12.4k|    , decltype(_impl_.high_tag_num_) { 0u }
 1057|       |
 1058|  12.4k|    , decltype(_impl_.low_tag_num_) { 0 }
 1059|       |
 1060|  12.4k|  };
 1061|  12.4k|}
_ZN8asn1_pdu9TagNumber10SharedDtorEv:
 1072|  12.4k|inline void TagNumber::SharedDtor() {
 1073|  12.4k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  12.4k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  12.4k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  12.4k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  12.4k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  12.4k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  12.4k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1074|  12.4k|}
_ZN8asn1_pdu6Length10SharedCtorEPN6google8protobuf5ArenaE:
 1299|  12.4k|inline void Length::SharedCtor(::_pb::Arena* arena) {
 1300|  12.4k|  (void)arena;
 1301|  12.4k|  new (&_impl_) Impl_{
 1302|  12.4k|      decltype(_impl_.types_){}
 1303|  12.4k|    , /*decltype(_impl_._cached_size_)*/{}
 1304|  12.4k|    , /*decltype(_impl_._oneof_case_)*/{}
 1305|  12.4k|  };
 1306|  12.4k|  clear_has_types();
 1307|  12.4k|}
_ZN8asn1_pdu6Length10SharedDtorEv:
 1318|  12.4k|inline void Length::SharedDtor() {
 1319|  12.4k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  12.4k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  12.4k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  12.4k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  12.4k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  12.4k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  12.4k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1320|  12.4k|  if (has_types()) {
  ------------------
  |  Branch (1320:7): [True: 2.61k, False: 9.83k]
  ------------------
 1321|  2.61k|    clear_types();
 1322|  2.61k|  }
 1323|  12.4k|}
_ZN8asn1_pdu12ValueElement10SharedCtorEPN6google8protobuf5ArenaE:
 1567|  15.3k|inline void ValueElement::SharedCtor(::_pb::Arena* arena) {
 1568|  15.3k|  (void)arena;
 1569|  15.3k|  new (&_impl_) Impl_{
 1570|  15.3k|      decltype(_impl_._has_bits_){}
 1571|  15.3k|    , /*decltype(_impl_._cached_size_)*/{}
 1572|  15.3k|    , decltype(_impl_.val_bits_) {}
 1573|       |
 1574|  15.3k|    , decltype(_impl_.pdu_){nullptr}
 1575|  15.3k|  };
 1576|  15.3k|  _impl_.val_bits_.InitDefault();
 1577|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 1578|       |        _impl_.val_bits_.Set("", GetArenaForAllocation());
 1579|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 1580|  15.3k|}
_ZN8asn1_pdu12ValueElement10SharedDtorEv:
 1591|  15.3k|inline void ValueElement::SharedDtor() {
 1592|  15.3k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  15.3k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  15.3k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  15.3k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  15.3k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  15.3k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  15.3k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1593|  15.3k|  _impl_.val_bits_.Destroy();
 1594|  15.3k|  if (this != internal_default_instance()) delete _impl_.pdu_;
  ------------------
  |  Branch (1594:7): [True: 15.3k, False: 0]
  ------------------
 1595|  15.3k|}
_ZN8asn1_pdu5Value10SharedCtorEPN6google8protobuf5ArenaE:
 1804|  12.5k|inline void Value::SharedCtor(::_pb::Arena* arena) {
 1805|  12.5k|  (void)arena;
 1806|  12.5k|  new (&_impl_) Impl_{
 1807|  12.5k|      decltype(_impl_.val_array_){arena}
 1808|  12.5k|    , /*decltype(_impl_._cached_size_)*/{}
 1809|  12.5k|  };
 1810|  12.5k|}
_ZN8asn1_pdu5Value10SharedDtorEv:
 1821|  12.5k|inline void Value::SharedDtor() {
 1822|  12.5k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  12.5k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  12.5k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  12.5k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  12.5k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  12.5k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  12.5k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1823|  12.5k|  _impl_.val_array_.~RepeatedPtrField();
 1824|  12.5k|}

_ZN8asn1_pdu3PDUC2Ev:
  214|  2.37k|  inline PDU() : PDU(nullptr) {}
_ZN8asn1_pdu3PDU25internal_default_instanceEv:
  261|  38.3k|  static inline const PDU* internal_default_instance() {
  262|  38.3k|    return reinterpret_cast<const PDU*>(
  263|  38.3k|               &_PDU_default_instance_);
  264|  38.3k|  }
_ZNK8asn1_pdu3PDU3NewEPN6google8protobuf5ArenaE:
  292|  10.4k|  PDU* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
  293|  10.4k|    return CreateMaybeMessage<PDU>(arena);
  294|  10.4k|  }
_ZN8asn1_pdu10Identifier25internal_default_instanceEv:
  455|  12.7k|  static inline const Identifier* internal_default_instance() {
  456|  12.7k|    return reinterpret_cast<const Identifier*>(
  457|  12.7k|               &_Identifier_default_instance_);
  458|  12.7k|  }
_ZNK8asn1_pdu10Identifier3NewEPN6google8protobuf5ArenaE:
  486|  12.7k|  Identifier* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
  487|  12.7k|    return CreateMaybeMessage<Identifier>(arena);
  488|  12.7k|  }
_ZNK8asn1_pdu9TagNumber3NewEPN6google8protobuf5ArenaE:
  674|  12.4k|  TagNumber* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
  675|  12.4k|    return CreateMaybeMessage<TagNumber>(arena);
  676|  12.4k|  }
_ZNK8asn1_pdu6Length3NewEPN6google8protobuf5ArenaE:
  849|  12.4k|  Length* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
  850|  12.4k|    return CreateMaybeMessage<Length>(arena);
  851|  12.4k|  }
_ZN8asn1_pdu6Length5Impl_10TypesUnionC2Ev:
  946|  12.4k|      constexpr TypesUnion() : _constinit_{} {}
_ZN8asn1_pdu12ValueElement25internal_default_instanceEv:
 1009|  15.3k|  static inline const ValueElement* internal_default_instance() {
 1010|  15.3k|    return reinterpret_cast<const ValueElement*>(
 1011|  15.3k|               &_ValueElement_default_instance_);
 1012|  15.3k|  }
_ZNK8asn1_pdu12ValueElement3NewEPN6google8protobuf5ArenaE:
 1040|  15.3k|  ValueElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 1041|  15.3k|    return CreateMaybeMessage<ValueElement>(arena);
 1042|  15.3k|  }
_ZNK8asn1_pdu5Value3NewEPN6google8protobuf5ArenaE:
 1222|  12.5k|  Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 1223|  12.5k|    return CreateMaybeMessage<Value>(arena);
 1224|  12.5k|  }
_ZNK8asn1_pdu3PDU12_internal_idEv:
 1329|  8.48k|inline const ::asn1_pdu::Identifier& PDU::_internal_id() const {
 1330|  8.48k|  const ::asn1_pdu::Identifier* p = _impl_.id_;
 1331|  8.48k|  return p != nullptr ? *p : reinterpret_cast<const ::asn1_pdu::Identifier&>(
  ------------------
  |  Branch (1331:10): [True: 8.48k, False: 0]
  ------------------
 1332|      0|      ::asn1_pdu::_Identifier_default_instance_);
 1333|  8.48k|}
_ZNK8asn1_pdu3PDU2idEv:
 1334|  8.48k|inline const ::asn1_pdu::Identifier& PDU::id() const {
 1335|       |  // @@protoc_insertion_point(field_get:asn1_pdu.PDU.id)
 1336|  8.48k|  return _internal_id();
 1337|  8.48k|}
_ZNK8asn1_pdu3PDU13_internal_lenEv:
 1416|  8.48k|inline const ::asn1_pdu::Length& PDU::_internal_len() const {
 1417|  8.48k|  const ::asn1_pdu::Length* p = _impl_.len_;
 1418|  8.48k|  return p != nullptr ? *p : reinterpret_cast<const ::asn1_pdu::Length&>(
  ------------------
  |  Branch (1418:10): [True: 8.48k, False: 0]
  ------------------
 1419|      0|      ::asn1_pdu::_Length_default_instance_);
 1420|  8.48k|}
_ZNK8asn1_pdu3PDU3lenEv:
 1421|  8.48k|inline const ::asn1_pdu::Length& PDU::len() const {
 1422|       |  // @@protoc_insertion_point(field_get:asn1_pdu.PDU.len)
 1423|  8.48k|  return _internal_len();
 1424|  8.48k|}
_ZNK8asn1_pdu3PDU13_internal_valEv:
 1503|  8.48k|inline const ::asn1_pdu::Value& PDU::_internal_val() const {
 1504|  8.48k|  const ::asn1_pdu::Value* p = _impl_.val_;
 1505|  8.48k|  return p != nullptr ? *p : reinterpret_cast<const ::asn1_pdu::Value&>(
  ------------------
  |  Branch (1505:10): [True: 8.48k, False: 0]
  ------------------
 1506|      0|      ::asn1_pdu::_Value_default_instance_);
 1507|  8.48k|}
_ZNK8asn1_pdu3PDU3valEv:
 1508|  8.48k|inline const ::asn1_pdu::Value& PDU::val() const {
 1509|       |  // @@protoc_insertion_point(field_get:asn1_pdu.PDU.val)
 1510|  8.48k|  return _internal_val();
 1511|  8.48k|}
_ZNK8asn1_pdu10Identifier8id_classEv:
 1593|  8.48k|inline ::asn1_pdu::Class Identifier::id_class() const {
 1594|       |  // @@protoc_insertion_point(field_get:asn1_pdu.Identifier.id_class)
 1595|  8.48k|  return _internal_id_class();
 1596|  8.48k|}
_ZNK8asn1_pdu10Identifier18_internal_id_classEv:
 1601|  8.48k|inline ::asn1_pdu::Class Identifier::_internal_id_class() const {
 1602|  8.48k|  return static_cast<::asn1_pdu::Class>(_impl_.id_class_);
 1603|  8.48k|}
_ZNK8asn1_pdu10Identifier8encodingEv:
 1619|  8.48k|inline ::asn1_pdu::Encoding Identifier::encoding() const {
 1620|       |  // @@protoc_insertion_point(field_get:asn1_pdu.Identifier.encoding)
 1621|  8.48k|  return _internal_encoding();
 1622|  8.48k|}
_ZNK8asn1_pdu10Identifier18_internal_encodingEv:
 1627|  8.48k|inline ::asn1_pdu::Encoding Identifier::_internal_encoding() const {
 1628|  8.48k|  return static_cast<::asn1_pdu::Encoding>(_impl_.encoding_);
 1629|  8.48k|}
_ZNK8asn1_pdu10Identifier17_internal_tag_numEv:
 1646|  16.9k|inline const ::asn1_pdu::TagNumber& Identifier::_internal_tag_num() const {
 1647|  16.9k|  const ::asn1_pdu::TagNumber* p = _impl_.tag_num_;
 1648|  16.9k|  return p != nullptr ? *p : reinterpret_cast<const ::asn1_pdu::TagNumber&>(
  ------------------
  |  Branch (1648:10): [True: 16.9k, False: 0]
  ------------------
 1649|      0|      ::asn1_pdu::_TagNumber_default_instance_);
 1650|  16.9k|}
_ZNK8asn1_pdu10Identifier7tag_numEv:
 1651|  16.9k|inline const ::asn1_pdu::TagNumber& Identifier::tag_num() const {
 1652|       |  // @@protoc_insertion_point(field_get:asn1_pdu.Identifier.tag_num)
 1653|  16.9k|  return _internal_tag_num();
 1654|  16.9k|}
_ZNK8asn1_pdu9TagNumber16has_high_tag_numEv:
 1728|  8.48k|inline bool TagNumber::has_high_tag_num() const {
 1729|  8.48k|  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
 1730|  8.48k|  return value;
 1731|  8.48k|}
_ZNK8asn1_pdu9TagNumber12high_tag_numEv:
 1736|  1.53k|inline ::uint32_t TagNumber::high_tag_num() const {
 1737|       |  // @@protoc_insertion_point(field_get:asn1_pdu.TagNumber.high_tag_num)
 1738|  1.53k|  return _internal_high_tag_num();
 1739|  1.53k|}
_ZNK8asn1_pdu9TagNumber22_internal_high_tag_numEv:
 1744|  1.53k|inline ::uint32_t TagNumber::_internal_high_tag_num() const {
 1745|  1.53k|  return _impl_.high_tag_num_;
 1746|  1.53k|}
_ZNK8asn1_pdu9TagNumber11low_tag_numEv:
 1761|  6.95k|inline ::asn1_pdu::LowTagNumber TagNumber::low_tag_num() const {
 1762|       |  // @@protoc_insertion_point(field_get:asn1_pdu.TagNumber.low_tag_num)
 1763|  6.95k|  return _internal_low_tag_num();
 1764|  6.95k|}
_ZNK8asn1_pdu9TagNumber21_internal_low_tag_numEv:
 1769|  6.95k|inline ::asn1_pdu::LowTagNumber TagNumber::_internal_low_tag_num() const {
 1770|  6.95k|  return static_cast<::asn1_pdu::LowTagNumber>(_impl_.low_tag_num_);
 1771|  6.95k|}
_ZNK8asn1_pdu6Length19has_indefinite_formEv:
 1783|  6.74k|inline bool Length::has_indefinite_form() const {
 1784|  6.74k|  return types_case() == kIndefiniteForm;
 1785|  6.74k|}
_ZNK8asn1_pdu6Length15indefinite_formEv:
 1795|    874|inline bool Length::indefinite_form() const {
 1796|       |  // @@protoc_insertion_point(field_get:asn1_pdu.Length.indefinite_form)
 1797|    874|  return _internal_indefinite_form();
 1798|    874|}
_ZNK8asn1_pdu6Length25_internal_indefinite_formEv:
 1803|    874|inline bool Length::_internal_indefinite_form() const {
 1804|    874|  if (types_case() == kIndefiniteForm) {
  ------------------
  |  Branch (1804:7): [True: 874, False: 0]
  ------------------
 1805|    874|    return _impl_.types_.indefinite_form_;
 1806|    874|  }
 1807|      0|  return false;
 1808|    874|}
_ZNK8asn1_pdu6Length19has_length_overrideEv:
 1818|  8.48k|inline bool Length::has_length_override() const {
 1819|  8.48k|  return types_case() == kLengthOverride;
 1820|  8.48k|}
_ZNK8asn1_pdu6Length15length_overrideEv:
 1830|  1.74k|inline const std::string& Length::length_override() const {
 1831|       |  // @@protoc_insertion_point(field_get:asn1_pdu.Length.length_override)
 1832|  1.74k|  return _internal_length_override();
 1833|  1.74k|}
_ZNK8asn1_pdu6Length25_internal_length_overrideEv:
 1851|  1.74k|inline const std::string& Length::_internal_length_override() const {
 1852|  1.74k|  if (types_case() != kLengthOverride) {
  ------------------
  |  Branch (1852:7): [True: 0, False: 1.74k]
  ------------------
 1853|      0|    return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
 1854|      0|  }
 1855|  1.74k|  return _impl_.types_.length_override_.Get();
 1856|  1.74k|}
_ZNK8asn1_pdu6Length9has_typesEv:
 1896|  12.4k|inline bool Length::has_types() const {
 1897|  12.4k|  return types_case() != TYPES_NOT_SET;
 1898|  12.4k|}
_ZN8asn1_pdu6Length15clear_has_typesEv:
 1899|  12.4k|inline void Length::clear_has_types() {
 1900|  12.4k|  _impl_._oneof_case_[0] = TYPES_NOT_SET;
 1901|  12.4k|}
_ZNK8asn1_pdu6Length10types_caseEv:
 1902|  42.1k|inline Length::TypesCase Length::types_case() const {
 1903|  42.1k|  return Length::TypesCase(_impl_._oneof_case_[0]);
 1904|  42.1k|}
_ZNK8asn1_pdu12ValueElement7has_pduEv:
 1910|  9.57k|inline bool ValueElement::has_pdu() const {
 1911|  9.57k|  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
 1912|  9.57k|  PROTOBUF_ASSUME(!value || _impl_.pdu_ != nullptr);
  ------------------
  |  |  616|  9.57k|  ABSL_DCHECK(pred);               \
  |  |  ------------------
  |  |  |  |   43|  9.57k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|  9.57k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   26|  9.57k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  157|  9.57k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   27|  9.57k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |  |  |   28|  9.57k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  617|  15.8k|  __builtin_assume(pred)
  |  |  ------------------
  |  |  |  Branch (617:20): [True: 3.27k, False: 6.29k]
  |  |  |  Branch (617:20): [True: 6.29k, False: 0]
  |  |  ------------------
  ------------------
 1913|  9.57k|  return value;
 1914|  9.57k|}
_ZNK8asn1_pdu12ValueElement13_internal_pduEv:
 1919|  6.29k|inline const ::asn1_pdu::PDU& ValueElement::_internal_pdu() const {
 1920|  6.29k|  const ::asn1_pdu::PDU* p = _impl_.pdu_;
 1921|  6.29k|  return p != nullptr ? *p : reinterpret_cast<const ::asn1_pdu::PDU&>(
  ------------------
  |  Branch (1921:10): [True: 6.29k, False: 0]
  ------------------
 1922|      0|      ::asn1_pdu::_PDU_default_instance_);
 1923|  6.29k|}
_ZNK8asn1_pdu12ValueElement3pduEv:
 1924|  6.29k|inline const ::asn1_pdu::PDU& ValueElement::pdu() const {
 1925|       |  // @@protoc_insertion_point(field_get:asn1_pdu.ValueElement.pdu)
 1926|  6.29k|  return _internal_pdu();
 1927|  6.29k|}
_ZNK8asn1_pdu12ValueElement8val_bitsEv:
 2005|  6.55k|inline const std::string& ValueElement::val_bits() const {
 2006|       |  // @@protoc_insertion_point(field_get:asn1_pdu.ValueElement.val_bits)
 2007|  6.55k|  return _internal_val_bits();
 2008|  6.55k|}
_ZNK8asn1_pdu12ValueElement18_internal_val_bitsEv:
 2021|  6.55k|inline const std::string& ValueElement::_internal_val_bits() const {
 2022|  6.55k|  return _impl_.val_bits_.Get();
 2023|  6.55k|}
_ZNK8asn1_pdu5Value9val_arrayEv:
 2100|  8.48k|Value::val_array() const {
 2101|       |  // @@protoc_insertion_point(field_list:asn1_pdu.Value.val_array)
 2102|  8.48k|  return _impl_.val_array_;
 2103|  8.48k|}