_ZN2bt15AdvertisingDataD2Ev:
  176|  10.2k|  ~AdvertisingData() = default;
_ZN2bt15AdvertisingData12SetLocalNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
  257|  22.1k|                                  bool is_complete = true) {
  258|  22.1k|    return SetLocalName(LocalName{name, is_complete});
  259|  22.1k|  }
_ZN2bt15AdvertisingData12BoundedUuidsC2Eh:
  326|  30.6k|    explicit BoundedUuids(uint8_t bound) : bound_(bound) {}
_ZNK2bt15AdvertisingData12BoundedUuids3setEv:
  332|  38.8k|    const std::unordered_set<UUID>& set() const { return set_; }
_ZN2bt15AdvertisingDataC2Ev:
  175|  3.60k|  AdvertisingData() = default;

_ZN2bt10ByteBufferD2Ev:
   48|   776k|  virtual ~ByteBuffer() = default;
_ZN2bt17DynamicByteBufferD2Ev:
  472|  51.2k|  ~DynamicByteBuffer() override = default;
_ZNK2bt10ByteBufferixEm:
  113|   699k|  inline const uint8_t& operator[](size_t pos) const {
  114|   699k|    PW_CHECK(pos < size(), "invalid offset (pos = %zu)", pos);
  ------------------
  |  |   39|   699k|  do {                                                                         \
  |  |   40|   699k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 699k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|   699k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|   699k|    return data()[pos];
  116|   699k|  }
_ZN2bt17MutableByteBufferixEm:
  315|  28.9k|  inline uint8_t& operator[](size_t pos) {
  316|  28.9k|    PW_CHECK(pos < size(), "invalid offset (pos = %zu)", pos);
  ------------------
  |  |   39|  28.9k|  do {                                                                         \
  |  |   40|  28.9k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 28.9k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  28.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  317|  28.9k|    return mutable_data()[pos];
  318|  28.9k|  }
_ZN2bt17MutableByteBuffer5WriteERKNS_10ByteBufferEm:
  337|  7.34k|  inline void Write(const ByteBuffer& data, size_t pos = 0) {
  338|  7.34k|    Write(data.data(), data.size(), pos);
  339|  7.34k|  }
_ZNK2bt10ByteBuffer2ToItEEDav:
  129|    380|  [[nodiscard]] auto To() const {
  130|    380|    static_assert(std::is_trivially_copyable_v<T>,
  131|    380|                  "unsafe to copy representation");
  132|    380|    static_assert(std::is_default_constructible_v<T>);
  133|    380|    using OutType = std::remove_cv_t<bt_lib_cpp_type::ToStdArrayT<T>>;
  134|       |
  135|       |    // This is value-initialized in order to construct objects that have const
  136|       |    // members. The consideration for modifying the object through its
  137|       |    // representation even if the constituent types are cv-qualified is based on
  138|       |    // the potent rules for memcpy'ing "underlying bytes" at ISO/IEC
  139|       |    // 14882:2017(E) § 6.9 [basic.types] ¶ 4.2–4.3.
  140|    380|    OutType out{};
  141|    380|    CopyRaw(/*dst_data=*/std::addressof(out),
  142|    380|            /*dst_capacity=*/sizeof(out),
  143|    380|            /*src_offset=*/0,
  144|    380|            /*copy_size=*/sizeof(out));
  145|    380|    return out;
  146|    380|  }

_ZN2bt8internal11CheckFormatEPKcz:
  129|  43.1k|constexpr void CheckFormat([[maybe_unused]] const char* fmt, ...) {}

_ZNK2bt20SupplementDataReader8is_validEv:
   88|  3.62k|  inline bool is_valid() const { return is_valid_; }

_ZN2bt8internal8ToStringINS_4UUIDEEENSt3__19enable_ifIXsr6detailE20HasToStringMemberFnVIT_EENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE4typeERKS5_:
   45|  10.8k|    const T& value) {
   46|  10.8k|  return value.ToString();
   47|  10.8k|}

_ZN2bt4UUIDC2ERKNSt3__15arrayIhLm16EEE:
   50|  21.3k|  constexpr explicit UUID(const UInt128& uuid128) : value_(uuid128) {
   51|  21.3k|    if (!IsValueCompressable())
  ------------------
  |  Branch (51:9): [True: 20.6k, False: 704]
  ------------------
   52|  20.6k|      return;
   53|       |
   54|    704|    if (value_[kBaseOffset + 2] == 0 && value_[kBaseOffset + 3] == 0) {
  ------------------
  |  Branch (54:9): [True: 483, False: 221]
  |  Branch (54:41): [True: 260, False: 223]
  ------------------
   55|    260|      type_ = Type::k16Bit;
   56|    444|    } else {
   57|    444|      type_ = Type::k32Bit;
   58|    444|    }
   59|    704|  }
_ZN2bt4UUIDC2Et:
   62|  15.7k|      : type_(Type::k16Bit), value_(BuildSIGUUID(uuid16)) {}
_ZN2bt4UUIDC2Ej:
   65|  10.2k|      : type_(uuid32 > std::numeric_limits<uint16_t>::max() ? Type::k32Bit
  ------------------
  |  Branch (65:15): [True: 9.98k, False: 220]
  ------------------
   66|  10.2k|                                                            : Type::k16Bit),
   67|  10.2k|        value_(BuildSIGUUID(uuid32)) {}
_ZN2bt4UUID12BuildSIGUUIDEt:
  169|  15.7k|  static constexpr UInt128 BuildSIGUUID(const uint16_t uuid16) {
  170|  15.7k|    return BuildSIGUUID(static_cast<uint32_t>(uuid16));
  171|  15.7k|  }
_ZN2bt4UUID12BuildSIGUUIDEj:
  174|  25.9k|  static constexpr UInt128 BuildSIGUUID(const uint32_t uuid32) {
  175|  25.9k|    UInt128 result(kBaseUuid);
  176|  25.9k|    result[kBaseOffset] = static_cast<uint8_t>(uuid32);
  177|  25.9k|    result[kBaseOffset + 1] = static_cast<uint8_t>(uuid32 >> 8);
  178|  25.9k|    result[kBaseOffset + 2] = static_cast<uint8_t>(uuid32 >> 16);
  179|  25.9k|    result[kBaseOffset + 3] = static_cast<uint8_t>(uuid32 >> 24);
  180|  25.9k|    return result;
  181|  25.9k|  }
_ZNK2bt4UUID19IsValueCompressableEv:
  185|  21.3k|  constexpr bool IsValueCompressable() const {
  186|       |    // C++14 allows for-loops in constexpr functions.
  187|  30.5k|    for (size_t i = 0; i < kBaseOffset; i++) {
  ------------------
  |  Branch (187:24): [True: 29.8k, False: 704]
  ------------------
  188|  29.8k|      if (kBaseUuid[i] != value_[i])
  ------------------
  |  Branch (188:11): [True: 20.6k, False: 9.15k]
  ------------------
  189|  20.6k|        return false;
  190|  29.8k|    }
  191|    704|    return true;
  192|  21.3k|  }
_ZNKSt3__14hashIN2bt4UUIDEEclERKS2_:
  249|  47.2k|  size_t operator()(const bt::UUID& k) const { return k.Hash(); }
_ZN2bt4UUIDC2Ev:
   44|  47.3k|  constexpr UUID() = default;

_ZN2pw5bytes16ConvertOrderFromItEET_N5cpp206endianES2_:
  133|  26.8k|constexpr T ConvertOrderFrom(endian from_endianness, T value) {
  134|  26.8k|  return ConvertOrder(from_endianness, endian::native, value);
  135|  26.8k|}
_ZN2pw5bytes12ConvertOrderItEET_N5cpp206endianES4_S2_:
  119|  26.8k|constexpr T ConvertOrder(endian from, endian to, T value) {
  120|  26.8k|  return from == to ? value : internal::ReverseBytes(value);
  ------------------
  |  Branch (120:10): [True: 26.8k, False: 0]
  ------------------
  121|  26.8k|}
_ZN2pw5bytes16ConvertOrderFromIjEET_N5cpp206endianES2_:
  133|  10.2k|constexpr T ConvertOrderFrom(endian from_endianness, T value) {
  134|  10.2k|  return ConvertOrder(from_endianness, endian::native, value);
  135|  10.2k|}
_ZN2pw5bytes12ConvertOrderIjEET_N5cpp206endianES4_S2_:
  119|  10.2k|constexpr T ConvertOrder(endian from, endian to, T value) {
  120|  10.2k|  return from == to ? value : internal::ReverseBytes(value);
  ------------------
  |  Branch (120:10): [True: 10.2k, False: 0]
  ------------------
  121|  10.2k|}

_ZN2pw15internal_result12StatusOrDataINS_3utf16CodePointAndSizeELb1EEC2INS_6StatusETnNSt3__19enable_ifIXsr3std16is_constructibleIS6_OT_EE5valueEiE4typeELi0EEESA_:
  218|  8.18k|      : status_(std::forward<U>(v)), unused_() {                               \
  219|  8.18k|    PW_ASSERT(!status_.ok());                                                  \
  220|  8.18k|  }                                                                            \
_ZN2pw15internal_result12StatusOrDataINS_3utf16CodePointAndSizeELb1EEC2IJS3_EEENSt3__110in_place_tEDpOT_:
  208|  28.5k|      : status_(), data_(std::forward<Args>(args)...) {}                       \
_ZN2pw15internal_result12StatusOrDataINS_4utf816EncodedCodePointELb1EEC2IJS3_EEENSt3__110in_place_tEDpOT_:
  208|  60.0k|      : status_(), data_(std::forward<Args>(args)...) {}                       \

_ZN2pw6ResultINS_3utf16CodePointAndSizeEEC2INS_6StatusETnNSt3__19enable_ifIXsr3std11conjunctionINS6_14is_convertibleIOT_S5_EENS6_16is_constructibleIS5_JSA_EEENS6_8negationINS6_7is_sameIu7__decayIS9_ES3_EEEENSE_INSF_ISG_S2_EEEENSE_INSF_ISG_NS6_10in_place_tEEEEENSE_INS_15internal_result29HasConversionOperatorToResultIS2_SA_vEEEEEE5valueEiE4typeELi0EEESA_:
  298|  8.18k|  constexpr Result(U&& v) : Base(std::forward<U>(v)) {}
_ZN2pw6ResultINS_3utf16CodePointAndSizeEEC2IS2_TnNSt3__19enable_ifIXsr3std11conjunctionINS5_11disjunctionIJNS5_7is_sameIS2_u11__remove_cvIu20__remove_reference_tIOT_EEEENS5_8negationINS7_IJNS8_IS3_SC_EENS8_INS_6StatusESC_EENS8_INS5_10in_place_tESC_EENS_15internal_result31IsDirectInitializationAmbiguousIS2_SA_EEEEEEEEEENS5_16is_constructibleIS2_JSA_EEENS5_14is_convertibleISA_S2_EENS7_IJNS8_Iu11__remove_cvIu20__remove_reference_tIS9_EES2_EENS5_11conjunctionIJNSE_INSS_ISA_SG_EEEENSE_INSK_29HasConversionOperatorToResultIS2_SA_vEEEEEEEEEEEE5valueEiE4typeELi0EEESA_:
  396|  28.5k|      : Result(std::in_place, std::forward<U>(u)) {}
_ZN2pw6ResultINS_3utf16CodePointAndSizeEEC2IJS2_EEENSt3__110in_place_tEDpOT_:
  770|  28.5k|    : Base(std::in_place, std::forward<Args>(args)...) {}
_ZNK2pw6ResultINS_3utf16CodePointAndSizeEE2okEv:
  430|  36.6k|  [[nodiscard]] constexpr bool ok() const { return this->status_.ok(); }
_ZNK2pw6ResultINS_3utf16CodePointAndSizeEEptEv:
  837|  56.2k|constexpr const T* Result<T>::operator->() const {
  838|  56.2k|  PW_ASSERT(this->status_.ok());
  839|  56.2k|  return &this->data_;
  840|  56.2k|}
_ZN2pw6ResultINS_4utf816EncodedCodePointEEC2IS2_TnNSt3__19enable_ifIXsr3std11conjunctionINS5_11disjunctionIJNS5_7is_sameIS2_u11__remove_cvIu20__remove_reference_tIOT_EEEENS5_8negationINS7_IJNS8_IS3_SC_EENS8_INS_6StatusESC_EENS8_INS5_10in_place_tESC_EENS_15internal_result31IsDirectInitializationAmbiguousIS2_SA_EEEEEEEEEENS5_16is_constructibleIS2_JSA_EEENS5_14is_convertibleISA_S2_EENS7_IJNS8_Iu11__remove_cvIu20__remove_reference_tIS9_EES2_EENS5_11conjunctionIJNSE_INSS_ISA_SG_EEEENSE_INSK_29HasConversionOperatorToResultIS2_SA_vEEEEEEEEEEEE5valueEiE4typeELi0EEESA_:
  396|  60.0k|      : Result(std::in_place, std::forward<U>(u)) {}
_ZN2pw6ResultINS_4utf816EncodedCodePointEEC2IJS2_EEENSt3__110in_place_tEDpOT_:
  770|  60.0k|    : Base(std::in_place, std::forward<Args>(args)...) {}
_ZNK2pw6ResultINS_4utf816EncodedCodePointEE2okEv:
  430|  45.5k|  [[nodiscard]] constexpr bool ok() const { return this->status_.ok(); }
_ZNK2pw6ResultINS_4utf816EncodedCodePointEEptEv:
  837|  60.0k|constexpr const T* Result<T>::operator->() const {
  838|  60.0k|  PW_ASSERT(this->status_.ok());
  839|  60.0k|  return &this->data_;
  840|  60.0k|}

_ZN2pw16pw_span_internal13ExtentStorageILm18446744073709551615EEC2Em:
  153|   269k|  constexpr explicit ExtentStorage(size_t size) noexcept : size_(size) {}
_ZNK2pw16pw_span_internal13ExtentStorageILm18446744073709551615EE4sizeEv:
  154|  3.95M|  constexpr size_t size() const noexcept { return size_; }
_ZNK2pw4spanIKSt4byteLm18446744073709551615EE4sizeEv:
  375|  3.14M|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZNK2pw4spanIKSt4byteLm18446744073709551615EE4dataEv:
  400|  3.05M|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanIcLm18446744073709551615EE4sizeEv:
  375|   680k|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZNK2pw4spanIcLm18446744073709551615EE5emptyEv:
  377|   356k|  [[nodiscard]] constexpr bool empty() const noexcept { return size() == 0; }
_ZNK2pw4spanIcLm18446744073709551615EE4dataEv:
  400|   356k|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanIcLm18446744073709551615EEixEm:
  380|   129k|  constexpr T& operator[](size_t idx) const noexcept {
  381|       |    // Note: CHECK_LT is not constexpr, hence regular CHECK must be used.
  382|   129k|    _PW_SPAN_ASSERT(idx < size());
  383|   129k|    return *(data() + idx);
  384|   129k|  }
_ZNK2pw4spanIKcLm18446744073709551615EE4dataEv:
  400|   215k|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanIKcLm18446744073709551615EE4sizeEv:
  375|   129k|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZNK2pw4spanIcLm18446744073709551615EE7subspanEmm:
  367|  43.1k|      size_t offset, size_t count = dynamic_extent) const noexcept {
  368|       |    // Note: CHECK_LE is not constexpr, hence regular CHECK must be used.
  369|  43.1k|    _PW_SPAN_ASSERT(offset <= size());
  370|  43.1k|    _PW_SPAN_ASSERT(count == dynamic_extent || count <= size() - offset);
  371|  43.1k|    return {data() + offset, count != dynamic_extent ? count : size() - offset};
  ------------------
  |  Branch (371:30): [True: 0, False: 43.1k]
  ------------------
  372|  43.1k|  }
_ZN2pw4spanIKSt4byteLm18446744073709551615EEC2EPS2_m:
  255|  43.1k|      : ExtentStorage(size), data_(data) {
  256|  43.1k|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|  43.1k|  }
_ZN2pw4spanIcLm18446744073709551615EEC2EPcm:
  255|  97.1k|      : ExtentStorage(size), data_(data) {
  256|  97.1k|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|  97.1k|  }
_ZN2pw4spanIcLm18446744073709551615EEC2ILm150EvEERAT__c:
  273|  43.1k|  constexpr span(T (&array)[N]) noexcept : span(std::data(array), N) {}
_ZN2pw4spanIKcLm18446744073709551615EEC2INSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEvEERT_:
  297|  43.1k|      : span(std::data(container), std::size(container)) {}
_ZN2pw4spanIKcLm18446744073709551615EEC2EPS1_m:
  255|   129k|      : ExtentStorage(size), data_(data) {
  256|   129k|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|   129k|  }
_ZN2pw8as_bytesIKcLm18446744073709551615EEENS_4spanIKSt4byteXqueqT0_L_ZNS_14dynamic_extentEEL_ZNS_14dynamic_extentEEmlstT_T0_EEENS2_IS5_XT0_EEE:
  425|  43.1k|as_bytes(span<T, X> s) noexcept {
  426|  43.1k|  return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  427|  43.1k|}
_ZNK2pw4spanIKcLm18446744073709551615EE10size_bytesEv:
  376|  43.1k|  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
_ZNK2pw4spanIKSt4byteLm18446744073709551615EE10size_bytesEv:
  376|  3.14M|  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
_ZNK2pw4spanIKSt4byteLm18446744073709551615EEixEm:
  380|  3.05M|  constexpr T& operator[](size_t idx) const noexcept {
  381|       |    // Note: CHECK_LT is not constexpr, hence regular CHECK must be used.
  382|  3.05M|    _PW_SPAN_ASSERT(idx < size());
  383|  3.05M|    return *(data() + idx);
  384|  3.05M|  }

_ZN2pw6Status15InvalidArgumentEv:
  101|  7.86k|  [[nodiscard]] static constexpr Status InvalidArgument() {
  102|  7.86k|    return PW_STATUS_INVALID_ARGUMENT;
  103|  7.86k|  }
_ZN2pw6StatusC2E9pw_Status:
  146|  3.41M|  constexpr Status(Code code = PW_STATUS_OK) : code_(code) {}
_ZNK2pw6Status2okEv:
  157|  3.35M|  [[nodiscard]] constexpr bool ok() const { return code_ == PW_STATUS_OK; }
_ZN2pw6Status10OutOfRangeEv:
  125|    316|  [[nodiscard]] static constexpr Status OutOfRange() {
  126|    316|    return PW_STATUS_OUT_OF_RANGE;
  127|    316|  }
_ZN2pw6Status17ResourceExhaustedEv:
  116|    754|  [[nodiscard]] static constexpr Status ResourceExhausted() {
  117|    754|    return PW_STATUS_RESOURCE_EXHAUSTED;
  118|    754|  }
_ZNK2pw6Status4codeEv:
  152|   260k|  constexpr Code code() const { return code_; }
_ZN2pw8OkStatusEv:
  234|  3.27M|[[nodiscard]] constexpr Status OkStatus() { return Status(); }

_ZN2pw14StatusWithSize17ResourceExhaustedEm:
   75|    754|  static constexpr StatusWithSize ResourceExhausted(size_t size = 0) {
   76|    754|    return StatusWithSize(Status::ResourceExhausted(), size);
   77|    754|  }
_ZN2pw14StatusWithSizeC2ENS_6StatusEm:
  113|  43.8k|      : StatusWithSize((static_cast<size_t>(status.code()) << kStatusShift) |
  114|  43.8k|                       size) {}
_ZNK2pw14StatusWithSize4sizeEv:
  146|  86.2k|  [[nodiscard]] constexpr size_t size() const { return size_ & kSizeMask; }
_ZNK2pw14StatusWithSize2okEv:
  152|  54.0k|  [[nodiscard]] constexpr bool ok() const {
  153|  54.0k|    return (size_ & kStatusMask) == 0u;
  154|  54.0k|  }
_ZNK2pw14StatusWithSize11IgnoreErrorEv:
  159|  43.1k|  constexpr void IgnoreError() const {}
_ZNK2pw14StatusWithSize6statusEv:
  161|  43.1k|  [[nodiscard]] constexpr Status status() const {
  162|  43.1k|    return static_cast<Status::Code>((size_ & kStatusMask) >> kStatusShift);
  163|  43.1k|  }
_ZN2pw14StatusWithSizeC2ImvEET_:
  107|  87.0k|  explicit constexpr StatusWithSize(T size) : size_(static_cast<size_t>(size)) {
  108|       |    // TODO(hepler): Add debug-only assert that size <= max_size().
  109|  87.0k|  }
_ZN2pw14StatusWithSizeC2IivEET_:
  107|  53.2k|  explicit constexpr StatusWithSize(T size) : size_(static_cast<size_t>(size)) {
  108|       |    // TODO(hepler): Add debug-only assert that size <= max_size().
  109|  53.2k|  }

_ZN2pw13StringBuilderC2ENS_4spanIcLm18446744073709551615EEE:
   91|  43.1k|      : buffer_(buffer), size_(&inline_size_), inline_size_(0) {
   92|  43.1k|    NullTerminate();
   93|  43.1k|  }
_ZNK2pw13StringBuilder4dataEv:
  114|  43.1k|  const char* data() const { return buffer_.data(); }
_ZNK2pw13StringBuilder4viewEv:
  120|  43.1k|  std::string_view view() const { return std::string_view(data(), size()); }
_ZNK2pw13StringBuildercvNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEv:
  124|  43.1k|  operator std::string_view() const { return view(); }
_ZNK2pw13StringBuilder4sizeEv:
  167|   474k|  size_t size() const { return *size_; }
_ZNK2pw13StringBuilder8max_sizeEv:
  170|  86.2k|  size_t max_size() const { return buffer_.empty() ? 0u : buffer_.size() - 1; }
  ------------------
  |  Branch (170:36): [True: 0, False: 86.2k]
  ------------------
_ZN2pw13StringBuilder10StatusCodeENS_6StatusE:
  291|   216k|  static constexpr unsigned char StatusCode(Status status) {
  292|   216k|    return static_cast<unsigned char>(status.code());
  293|   216k|  }
_ZN2pw13StringBuilder13NullTerminateEv:
  301|   129k|  constexpr void NullTerminate() {
  302|   129k|    if (!buffer_.empty()) {
  ------------------
  |  Branch (302:9): [True: 129k, False: 0]
  ------------------
  303|   129k|      buffer_[size()] = '\0';
  304|   129k|    }
  305|   129k|  }
_ZN2pw13StringBuilderlsIPKcEERS0_RKT_:
  224|  43.1k|  StringBuilder& operator<<(const T& value) {
  225|       |    /// For types compatible with `std::string_view`, use the `append` function,
  226|       |    /// which gives smaller code size.
  227|  43.1k|    if constexpr (std::is_convertible_v<T, std::string_view>) {
  228|  43.1k|      append(value);
  229|       |    } else if constexpr (std::is_convertible_v<T, span<const std::byte>>) {
  230|       |      WriteBytes(value);
  231|       |    } else {
  232|       |      HandleStatusWithSize(ToString(value, buffer_.subspan(size())));
  233|       |    }
  234|  43.1k|    return *this;
  235|  43.1k|  }
_ZN2pw12StringBufferILm150EEC2Ev:
  333|  43.1k|  StringBuffer() : StringBuilder(buffer_) {}
_ZN2pw12StringBufferILm150EElsIPKcEERS1_OT_:
  387|  43.1k|  StringBuffer& operator<<(T&& value) {
  388|  43.1k|    static_cast<StringBuilder&>(*this) << std::forward<T>(value);
  389|  43.1k|    return *this;
  390|  43.1k|  }
_ZN2pw12StringBufferILm150EElsIRA3_KcEERS1_OT_:
  387|  43.1k|  StringBuffer& operator<<(T&& value) {
  388|  43.1k|    static_cast<StringBuilder&>(*this) << std::forward<T>(value);
  389|  43.1k|    return *this;
  390|  43.1k|  }
_ZN2pw13StringBuilderlsIA3_cEERS0_RKT_:
  224|  43.1k|  StringBuilder& operator<<(const T& value) {
  225|       |    /// For types compatible with `std::string_view`, use the `append` function,
  226|       |    /// which gives smaller code size.
  227|  43.1k|    if constexpr (std::is_convertible_v<T, std::string_view>) {
  228|  43.1k|      append(value);
  229|       |    } else if constexpr (std::is_convertible_v<T, span<const std::byte>>) {
  230|       |      WriteBytes(value);
  231|       |    } else {
  232|       |      HandleStatusWithSize(ToString(value, buffer_.subspan(size())));
  233|       |    }
  234|  43.1k|    return *this;
  235|  43.1k|  }

_ZN2pw4utf813ReadCodePointENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  105|  36.6k|    std::string_view str) {
  106|  36.6k|  if (str.empty()) {
  ------------------
  |  Branch (106:7): [True: 1.02k, False: 35.6k]
  ------------------
  107|  1.02k|    return pw::Status::InvalidArgument();
  108|  1.02k|  }
  109|       |
  110|  35.6k|  const uint8_t leading_byte = static_cast<uint8_t>(str.front());
  111|  35.6k|  size_t byte_count = 0;
  112|  35.6k|  uint32_t code_point = 0xFFFFFFFFu;
  113|       |
  114|  35.6k|  if (leading_byte <= 0x7F) {
  ------------------
  |  Branch (114:7): [True: 27.8k, False: 7.80k]
  ------------------
  115|  27.8k|    byte_count = 1;
  116|       |    // b0xxx xxxx
  117|  27.8k|    code_point = leading_byte;
  118|  27.8k|  } else if (leading_byte <= 0xDF) {
  ------------------
  |  Branch (118:14): [True: 1.25k, False: 6.54k]
  ------------------
  119|  1.25k|    byte_count = 2;
  120|  1.25k|    if (str.size() < byte_count) {
  ------------------
  |  Branch (120:9): [True: 501, False: 756]
  ------------------
  121|    501|      return pw::Status::InvalidArgument();
  122|    501|    }
  123|       |    // b110x xxxx 10xx xxxx
  124|    756|    if ((str[1] & 0xC0) != 0x80) {
  ------------------
  |  Branch (124:9): [True: 363, False: 393]
  ------------------
  125|       |      // Invalid continuation
  126|    363|      return pw::Status::InvalidArgument();
  127|    363|    }
  128|    393|    code_point = (static_cast<uint32_t>(str[0] & 0x1F) << 6) +
  129|    393|                 static_cast<uint32_t>(str[1] & 0x3F);
  130|  6.54k|  } else if (leading_byte <= 0xEF) {
  ------------------
  |  Branch (130:14): [True: 4.16k, False: 2.38k]
  ------------------
  131|  4.16k|    byte_count = 3;
  132|  4.16k|    if (str.size() < byte_count) {
  ------------------
  |  Branch (132:9): [True: 1.08k, False: 3.07k]
  ------------------
  133|  1.08k|      return pw::Status::InvalidArgument();
  134|  1.08k|    }
  135|  3.07k|    if ((str[1] & 0xC0) != 0x80 || (str[2] & 0xC0) != 0x80) {
  ------------------
  |  Branch (135:9): [True: 547, False: 2.53k]
  |  Branch (135:36): [True: 2.20k, False: 327]
  ------------------
  136|       |      // Invalid continuation
  137|  2.75k|      return pw::Status::InvalidArgument();
  138|  2.75k|    }
  139|       |    // b1110 xxxx 10xx xxxx 10xx xxxx
  140|    327|    code_point = (static_cast<uint32_t>(str[0] & 0x0F) << 12) +
  141|    327|                 (static_cast<uint32_t>(str[1] & 0x3F) << 6) +
  142|    327|                 static_cast<uint32_t>(str[2] & 0x3F);
  143|  2.38k|  } else if (leading_byte <= 0xF7) {
  ------------------
  |  Branch (143:14): [True: 1.34k, False: 1.04k]
  ------------------
  144|  1.34k|    byte_count = 4;
  145|  1.34k|    if (str.size() < byte_count) {
  ------------------
  |  Branch (145:9): [True: 504, False: 837]
  ------------------
  146|    504|      return pw::Status::InvalidArgument();
  147|    504|    }
  148|    837|    if ((str[1] & 0xC0) != 0x80 || (str[2] & 0xC0) != 0x80 ||
  ------------------
  |  Branch (148:9): [True: 206, False: 631]
  |  Branch (148:36): [True: 195, False: 436]
  ------------------
  149|    837|        (str[3] & 0xC0) != 0x80) {
  ------------------
  |  Branch (149:9): [True: 195, False: 241]
  ------------------
  150|       |      // Invalid continuation
  151|    596|      return pw::Status::InvalidArgument();
  152|    596|    }
  153|       |    // b1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx
  154|    241|    code_point = (static_cast<uint32_t>(str[0] & 0x07) << 18) +
  155|    241|                 (static_cast<uint32_t>(str[1] & 0x3F) << 12) +
  156|    241|                 (static_cast<uint32_t>(str[2] & 0x3F) << 6) +
  157|    241|                 static_cast<uint32_t>(str[3] & 0x3F);
  158|  1.04k|  } else {
  159|  1.04k|    return pw::Status::InvalidArgument();
  160|  1.04k|  }
  161|       |
  162|       |  // Validate the decoded value.
  163|  28.8k|  if (utf::IsValidCodepoint(code_point)) {
  ------------------
  |  Branch (163:7): [True: 28.5k, False: 316]
  ------------------
  164|  28.5k|    return utf::CodePointAndSize(code_point, byte_count);
  165|  28.5k|  }
  166|       |
  167|    316|  return pw::Status::OutOfRange();
  168|  28.8k|}
_ZN2pw3utf16IsValidCodepointEj:
   34|  28.8k|constexpr inline bool IsValidCodepoint(uint32_t code_point) {
   35|  28.8k|  return code_point < 0xD800u ||
  ------------------
  |  Branch (35:10): [True: 28.2k, False: 551]
  ------------------
   36|  28.8k|         (code_point >= 0xE000u && code_point <= 0x10FFFFu);
  ------------------
  |  Branch (36:11): [True: 317, False: 234]
  |  Branch (36:36): [True: 235, False: 82]
  ------------------
   37|  28.8k|}
_ZN2pw3utf16CodePointAndSizeC2Ejm:
   61|  28.5k|      : code_point_((static_cast<uint32_t>(size) << kSizeShift) | code_point) {}
_ZNK2pw3utf16CodePointAndSize10code_pointEv:
   69|  28.5k|  constexpr uint32_t code_point() const { return code_point_ & kCodePointMask; }
_ZNK2pw3utf16CodePointAndSize4sizeEv:
   72|  27.7k|  constexpr size_t size() const {
   73|  27.7k|    return (code_point_ & kSizeMask) >> kSizeShift;
   74|  27.7k|  }
_ZN2pw4utf815EncodeCodePointEj:
  221|  60.0k|constexpr Result<EncodedCodePoint> EncodeCodePoint(uint32_t code_point) {
  222|  60.0k|  if (code_point <= 0x7F) {
  ------------------
  |  Branch (222:7): [True: 59.5k, False: 513]
  ------------------
  223|  59.5k|    return EncodedCodePoint{1, {static_cast<char>(code_point)}};
  224|  59.5k|  }
  225|    513|  if (code_point <= 0x7FF) {
  ------------------
  |  Branch (225:7): [True: 513, False: 0]
  ------------------
  226|    513|    return EncodedCodePoint{2,
  227|    513|                            {static_cast<char>(0xC0 | (code_point >> 6)),
  228|    513|                             static_cast<char>(0x80 | (code_point & 0x3F))}};
  229|    513|  }
  230|      0|  if (code_point <= 0xFFFF) {
  ------------------
  |  Branch (230:7): [True: 0, False: 0]
  ------------------
  231|      0|    return EncodedCodePoint{
  232|      0|        3,
  233|      0|        {static_cast<char>(0xE0 | (code_point >> 12)),
  234|      0|         static_cast<char>(0x80 | ((code_point >> 6) & 0x3F)),
  235|      0|         static_cast<char>(0x80 | (code_point & 0x3F))}};
  236|      0|  }
  237|      0|  if (code_point <= 0x10FFFF) {
  ------------------
  |  Branch (237:7): [True: 0, False: 0]
  ------------------
  238|      0|    return EncodedCodePoint{
  239|      0|        4,
  240|      0|        {static_cast<char>(0xF0 | (code_point >> 18)),
  241|      0|         static_cast<char>(0x80 | ((code_point >> 12) & 0x3F)),
  242|      0|         static_cast<char>(0x80 | ((code_point >> 6) & 0x3F)),
  243|      0|         static_cast<char>(0x80 | (code_point & 0x3F))}};
  244|      0|  }
  245|       |
  246|      0|  return pw::Status::OutOfRange();
  247|      0|}
_ZN2pw4utf816EncodedCodePointC2EjNSt3__15arrayIcLm4EEE:
  186|  60.0k|      : size_(size), data_(std::move(data)) {}
_ZNK2pw4utf816EncodedCodePoint7as_viewEv:
  188|  60.0k|  constexpr std::string_view as_view() const { return {data_.data(), size_}; }

_ZN2pw6string8internal13ClampedLengthEPKcm:
   30|  86.2k|constexpr size_t ClampedLength(const char* str, size_t max_len) {
   31|  86.2k|  size_t length = 0;
   32|       |
   33|  86.2k|  if (str != nullptr) {
  ------------------
  |  Branch (33:7): [True: 86.2k, False: 0]
  ------------------
   34|   862k|    for (; length < max_len; ++length) {
  ------------------
  |  Branch (34:12): [True: 862k, False: 0]
  ------------------
   35|   862k|      if (str[length] == '\0') {
  ------------------
  |  Branch (35:11): [True: 86.2k, False: 776k]
  ------------------
   36|  86.2k|        break;
   37|  86.2k|      }
   38|   862k|    }
   39|  86.2k|  }
   40|       |
   41|  86.2k|  return length;
   42|  86.2k|}

_ZN2pw6string14ClampedCStringENS_4spanIKcLm18446744073709551615EEE:
   58|  86.2k|constexpr std::string_view ClampedCString(span<const char> str) {
   59|  86.2k|  return std::string_view(str.data(),
   60|  86.2k|                          internal::ClampedLength(str.data(), str.size()));
   61|  86.2k|}
_ZN2pw6string14ClampedCStringEPKcm:
   63|  86.2k|constexpr std::string_view ClampedCString(const char* str, size_t max_len) {
   64|  86.2k|  return ClampedCString(span<const char>(str, max_len));
   65|  86.2k|}

_ZN2bt15AdvertisingDataC2EOS0_:
  180|  6.61k|AdvertisingData::AdvertisingData(AdvertisingData&& other) noexcept {
  181|  6.61k|  *this = std::move(other);
  182|  6.61k|}
_ZN2bt15AdvertisingDataaSEOS0_:
  184|  6.61k|AdvertisingData& AdvertisingData::operator=(AdvertisingData&& other) noexcept {
  185|       |  // Reset `other`'s state to that of a fresh, empty AdvertisingData
  186|  6.61k|  local_name_ = std::exchange(other.local_name_, {});
  187|  6.61k|  tx_power_ = std::exchange(other.tx_power_, {});
  188|  6.61k|  appearance_ = std::exchange(other.appearance_, {});
  189|  6.61k|  service_uuids_ = std::exchange(other.service_uuids_, kEmptyServiceUuidMap);
  190|  6.61k|  solicitation_uuids_ =
  191|  6.61k|      std::exchange(other.solicitation_uuids_, kEmptyServiceUuidMap);
  192|  6.61k|  manufacturer_data_ = std::exchange(other.manufacturer_data_, {});
  193|  6.61k|  service_data_ = std::exchange(other.service_data_, {});
  194|  6.61k|  uris_ = std::exchange(other.uris_, {});
  195|  6.61k|  flags_ = std::exchange(other.flags_, {});
  196|  6.61k|  resolvable_set_identifier_ =
  197|  6.61k|      std::exchange(other.resolvable_set_identifier_, {});
  198|  6.61k|  broadcast_name_ = std::exchange(other.broadcast_name_, {});
  199|  6.61k|  return *this;
  200|  6.61k|}
_ZN2bt15AdvertisingData9FromBytesERKNS_10ByteBufferE:
  367|  3.62k|    const ByteBuffer& data) {
  368|  3.62k|  if (data.size() == 0) {
  ------------------
  |  Branch (368:7): [True: 5, False: 3.62k]
  ------------------
  369|      5|    return fit::error(ParseError::kMissing);
  370|      5|  }
  371|  3.62k|  SupplementDataReader reader(data);
  372|  3.62k|  if (!reader.is_valid()) {
  ------------------
  |  Branch (372:7): [True: 19, False: 3.60k]
  ------------------
  373|     19|    return fit::error(ParseError::kInvalidTlvFormat);
  374|     19|  }
  375|       |
  376|  3.60k|  AdvertisingData out_ad;
  377|  3.60k|  DataType type;
  378|  3.60k|  BufferView field;
  379|   150k|  while (reader.GetNextField(&type, &field)) {
  ------------------
  |  Branch (379:10): [True: 147k, False: 3.30k]
  ------------------
  380|       |    // While parsing through the advertising data fields, we do not need to
  381|       |    // validate that per-field sizes do not overflow a uint8_t because they, by
  382|       |    // construction, are obtained from a uint8_t.
  383|   147k|    PW_DCHECK(field.size() <= std::numeric_limits<uint8_t>::max());
  ------------------
  |  |   51|   147k|  do {                            \
  |  |   52|   147k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |   53|   147k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|   147k|  do {                                                                         \
  |  |  |  |   40|   147k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 147k]
  |  |  |  |  ------------------
  |  |  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |  |  |   45|      0|      }                                                                        \
  |  |  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   47|      0|    }                                                                          \
  |  |  |  |   48|   147k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|   147k|    }                             \
  |  |   55|   147k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  384|   147k|    PW_MODIFY_DIAGNOSTICS_PUSH();
  385|   147k|    PW_MODIFY_DIAGNOSTIC(ignored, "-Wswitch-enum");
  386|   147k|    switch (type) {
  387|    591|      case DataType::kTxPowerLevel: {
  ------------------
  |  Branch (387:7): [True: 591, False: 146k]
  ------------------
  388|    591|        if (field.size() != kTxPowerLevelSize) {
  ------------------
  |  Branch (388:13): [True: 18, False: 573]
  ------------------
  389|     18|          return fit::error(ParseError::kTxPowerLevelMalformed);
  390|     18|        }
  391|       |
  392|    573|        out_ad.SetTxPower(static_cast<int8_t>(field[0]));
  393|    573|        break;
  394|    591|      }
  395|  7.52k|      case DataType::kShortenedLocalName: {
  ------------------
  |  Branch (395:7): [True: 7.52k, False: 140k]
  ------------------
  396|  7.52k|        if (field.ToString().size() > kMaxNameLength) {
  ------------------
  |  Branch (396:13): [True: 2, False: 7.52k]
  ------------------
  397|      2|          return fit::error(ParseError::kLocalNameTooLong);
  398|      2|        }
  399|       |
  400|  7.52k|        (void)out_ad.SetLocalName(field.ToString(), /*is_complete=*/false);
  401|  7.52k|        break;
  402|  7.52k|      }
  403|  14.6k|      case DataType::kCompleteLocalName: {
  ------------------
  |  Branch (403:7): [True: 14.6k, False: 132k]
  ------------------
  404|  14.6k|        if (field.ToString().size() > kMaxNameLength) {
  ------------------
  |  Branch (404:13): [True: 3, False: 14.6k]
  ------------------
  405|      3|          return fit::error(ParseError::kLocalNameTooLong);
  406|      3|        }
  407|       |
  408|  14.6k|        (void)out_ad.SetLocalName(field.ToString(), /*is_complete=*/true);
  409|  14.6k|        break;
  410|  14.6k|      }
  411|    371|      case DataType::kIncomplete16BitServiceUuids:
  ------------------
  |  Branch (411:7): [True: 371, False: 147k]
  ------------------
  412|  1.39k|      case DataType::kComplete16BitServiceUuids:
  ------------------
  |  Branch (412:7): [True: 1.02k, False: 146k]
  ------------------
  413|  2.34k|      case DataType::kIncomplete32BitServiceUuids:
  ------------------
  |  Branch (413:7): [True: 945, False: 146k]
  ------------------
  414|  11.4k|      case DataType::kComplete32BitServiceUuids:
  ------------------
  |  Branch (414:7): [True: 9.09k, False: 138k]
  ------------------
  415|  13.0k|      case DataType::kIncomplete128BitServiceUuids:
  ------------------
  |  Branch (415:7): [True: 1.65k, False: 145k]
  ------------------
  416|  14.3k|      case DataType::kComplete128BitServiceUuids: {
  ------------------
  |  Branch (416:7): [True: 1.26k, False: 146k]
  ------------------
  417|       |        // AddServiceUuid fails when the number of N bit UUIDs exceed the
  418|       |        // kMaxNBitUuids bounds. These bounds are based on the number of UUIDs
  419|       |        // that fit in the wire (byte) representation of an AdvertisingData, so
  420|       |        // for valid AdvertisingData packets, the number of N bit service UUIDs
  421|       |        // cannot exceed the bounds limits. However, because invalid packets may
  422|       |        // provide multiple DataType fields for the same UUID (not allowed by
  423|       |        // CSS v9 Part A 1.1.1), this limit may be exceeded, in which case we
  424|       |        // reject the packet.
  425|  14.3k|        if (!ParseUuids(
  ------------------
  |  Branch (425:13): [True: 185, False: 14.1k]
  ------------------
  426|  14.3k|                field,
  427|  14.3k|                SizeForType(type),
  428|  14.3k|                fit::bind_member<&AdvertisingData::AddServiceUuid>(&out_ad))) {
  429|    185|          return fit::error(ParseError::kUuidsMalformed);
  430|    185|        }
  431|  14.1k|        break;
  432|  14.3k|      }
  433|  14.1k|      case DataType::kSolicitationUuid16Bit:
  ------------------
  |  Branch (433:7): [True: 339, False: 147k]
  ------------------
  434|    624|      case DataType::kSolicitationUuid32Bit:
  ------------------
  |  Branch (434:7): [True: 285, False: 147k]
  ------------------
  435|    955|      case DataType::kSolicitationUuid128Bit: {
  ------------------
  |  Branch (435:7): [True: 331, False: 147k]
  ------------------
  436|    955|        if (!ParseUuids(field,
  ------------------
  |  Branch (436:13): [True: 10, False: 945]
  ------------------
  437|    955|                        SizeForType(type),
  438|    955|                        fit::bind_member<&AdvertisingData::AddSolicitationUuid>(
  439|    955|                            &out_ad))) {
  440|     10|          return fit::error(ParseError::kUuidsMalformed);
  441|     10|        }
  442|    945|        break;
  443|    955|      }
  444|  10.7k|      case DataType::kManufacturerSpecificData: {
  ------------------
  |  Branch (444:7): [True: 10.7k, False: 136k]
  ------------------
  445|  10.7k|        if (field.size() < kManufacturerSpecificDataSizeMin) {
  ------------------
  |  Branch (445:13): [True: 10, False: 10.7k]
  ------------------
  446|     10|          return fit::error(ParseError::kManufacturerSpecificDataTooSmall);
  447|     10|        }
  448|       |
  449|  10.7k|        uint16_t id = static_cast<uint16_t>(pw::bytes::ConvertOrderFrom(
  450|  10.7k|            cpp20::endian::little,
  451|  10.7k|            *reinterpret_cast<const uint16_t*>(field.data())));
  452|  10.7k|        const BufferView manuf_data(field.data() + kManufacturerIdSize,
  453|  10.7k|                                    field.size() - kManufacturerIdSize);
  454|       |
  455|  10.7k|        PW_CHECK(out_ad.SetManufacturerData(id, manuf_data));
  ------------------
  |  |   39|  10.7k|  do {                                                                         \
  |  |   40|  10.7k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 10.7k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  10.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  456|  10.7k|        break;
  457|  10.7k|      }
  458|  10.7k|      case DataType::kServiceData16Bit:
  ------------------
  |  Branch (458:7): [True: 4.72k, False: 142k]
  ------------------
  459|  8.61k|      case DataType::kServiceData32Bit:
  ------------------
  |  Branch (459:7): [True: 3.89k, False: 143k]
  ------------------
  460|  23.6k|      case DataType::kServiceData128Bit: {
  ------------------
  |  Branch (460:7): [True: 15.0k, False: 132k]
  ------------------
  461|  23.6k|        UUID uuid;
  462|  23.6k|        size_t uuid_size = SizeForType(type);
  463|  23.6k|        if (field.size() < uuid_size) {
  ------------------
  |  Branch (463:13): [True: 26, False: 23.6k]
  ------------------
  464|     26|          return fit::error(ParseError::kServiceDataTooSmall);
  465|     26|        }
  466|  23.6k|        const BufferView uuid_bytes(field.data(), uuid_size);
  467|  23.6k|        if (!UUID::FromBytes(uuid_bytes, &uuid)) {
  ------------------
  |  Branch (467:13): [True: 0, False: 23.6k]
  ------------------
  468|      0|          return fit::error(ParseError::kServiceDataUuidMalformed);
  469|      0|        }
  470|  23.6k|        const BufferView service_data(field.data() + uuid_size,
  471|  23.6k|                                      field.size() - uuid_size);
  472|  23.6k|        PW_CHECK(out_ad.SetServiceData(uuid, service_data));
  ------------------
  |  |   39|  23.6k|  do {                                                                         \
  |  |   40|  23.6k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 23.6k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  23.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  473|  23.6k|        break;
  474|  23.6k|      }
  475|  23.6k|      case DataType::kAppearance: {
  ------------------
  |  Branch (475:7): [True: 396, False: 147k]
  ------------------
  476|       |        // TODO(armansito): Peer should have a function to return the
  477|       |        // device appearance, as it can be obtained either from advertising data
  478|       |        // or via GATT.
  479|    396|        if (field.size() != kAppearanceSize) {
  ------------------
  |  Branch (479:13): [True: 16, False: 380]
  ------------------
  480|     16|          return fit::error(ParseError::kAppearanceMalformed);
  481|     16|        }
  482|       |
  483|    380|        out_ad.SetAppearance(pw::bytes::ConvertOrderFrom(cpp20::endian::little,
  484|    380|                                                         field.To<uint16_t>()));
  485|    380|        break;
  486|    396|      }
  487|  39.7k|      case DataType::kURI: {
  ------------------
  |  Branch (487:7): [True: 39.7k, False: 107k]
  ------------------
  488|       |        // Assertion is safe as AddUri only fails when field size > uint8_t,
  489|       |        // which is impossible.
  490|  39.7k|        PW_CHECK(out_ad.AddUri(DecodeUri(field.ToString())));
  ------------------
  |  |   39|  39.7k|  do {                                                                         \
  |  |   40|  39.7k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 39.7k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  39.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  491|  39.7k|        break;
  492|  39.7k|      }
  493|  39.7k|      case DataType::kFlags: {
  ------------------
  |  Branch (493:7): [True: 19.0k, False: 128k]
  ------------------
  494|       |        // Flags field may be zero or more octets long but we only store the
  495|       |        // first octet.
  496|  19.0k|        if (field.size() > 0) {
  ------------------
  |  Branch (496:13): [True: 13.3k, False: 5.74k]
  ------------------
  497|  13.3k|          out_ad.SetFlags(field[0]);
  498|  13.3k|        } else {
  499|  5.74k|          out_ad.SetFlags(0);
  500|  5.74k|        }
  501|  19.0k|        break;
  502|  39.7k|      }
  503|    467|      case DataType::kResolvableSetIdentifier: {
  ------------------
  |  Branch (503:7): [True: 467, False: 147k]
  ------------------
  504|    467|        if (field.size() != kResolvableSetIdentifierSize) {
  ------------------
  |  Branch (504:13): [True: 18, False: 449]
  ------------------
  505|     18|          return fit::error(ParseError::kResolvableSetIdentifierSize);
  506|     18|        }
  507|    449|        std::array<uint8_t, kResolvableSetIdentifierSize> ident{
  508|    449|            field[0], field[1], field[2], field[3], field[4], field[5]};
  509|    449|        out_ad.SetResolvableSetIdentifier(ident);
  510|    449|        break;
  511|    467|      }
  512|  1.18k|      case DataType::kBroadcastName: {
  ------------------
  |  Branch (512:7): [True: 1.18k, False: 146k]
  ------------------
  513|  1.18k|        if (field.size() < kMinBroadcastNameBytes) {
  ------------------
  |  Branch (513:13): [True: 8, False: 1.17k]
  ------------------
  514|      8|          return fit::error(ParseError::kBroadcastNameTooShort);
  515|      8|        }
  516|  1.17k|        if (field.size() > kMaxBroadcastNameBytes) {
  ------------------
  |  Branch (516:13): [True: 1, False: 1.17k]
  ------------------
  517|      1|          return fit::error(ParseError::kBroadcastNameTooLong);
  518|      1|        }
  519|  1.17k|        std::string name = field.ToString();
  520|  1.17k|        out_ad.SetBroadcastName(name);
  521|  1.17k|        break;
  522|  1.17k|      }
  523|  14.2k|      default:
  ------------------
  |  Branch (523:7): [True: 14.2k, False: 133k]
  ------------------
  524|  14.2k|        bt_log(DEBUG,
  ------------------
  |  |  141|  14.2k|  PW_LOG(static_cast<int>(bt::LogSeverity::level), \
  |  |  ------------------
  |  |  |  |   73|  14.2k|  do {                                                                     \
  |  |  |  |   74|  14.2k|    if (PW_LOG_ENABLE_IF(level, verbosity, module, flags)) {               \
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|  14.2k|  ((int32_t)(level) >= (int32_t)(verbosity))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (43:3): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   75|  14.2k|      PW_HANDLE_LOG(level, module, flags, __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|  14.2k|  do {                                                    \
  |  |  |  |  |  |   56|  14.2k|    pw_Log((level),                                       \
  |  |  |  |  |  |   57|  14.2k|           (flags),                                       \
  |  |  |  |  |  |   58|  14.2k|           module,                                        \
  |  |  |  |  |  |   59|  14.2k|           __FILE__,                                      \
  |  |  |  |  |  |   60|  14.2k|           __LINE__,                                      \
  |  |  |  |  |  |   61|  14.2k|           __func__,                                      \
  |  |  |  |  |  |   62|  14.2k|           message PW_COMMA_ARGS(__VA_ARGS__));           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   57|  14.2k|  _PW_IF(PW_EMPTY_ARGS(__VA_ARGS__), _PW_EXPAND, _PW_COMMA_ARGS) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   21|  14.2k|  _PW_PASTE2(_PW_IF_, boolean)(true_expr, false_expr)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   27|  14.2k|#define _PW_PASTE2(a1, a2) _PW_PASTE2_EXPANDED(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   28|  14.2k|#define _PW_PASTE2_EXPANDED(a1, a2) _PW_PASTE2_IMPL(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   29|  14.2k|#define _PW_PASTE2_IMPL(a1, a2) a1##a2
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   58|  14.2k|  (PW_DROP_LAST_ARG_IF_EMPTY(__VA_ARGS__))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  14.2k|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   76|  14.2k|    }                                                                      \
  |  |  |  |   77|  14.2k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (77:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  142|  14.2k|         PW_LOG_LEVEL,                             \
  |  |  143|  14.2k|         tag,                                      \
  |  |  144|  14.2k|         GetPwLogFlags(bt::LogSeverity::level),    \
  |  |  145|  14.2k|         __VA_ARGS__);                             \
  |  |  146|  14.2k|  ::bt::internal::CheckFormat(tag)
  ------------------
  525|  14.2k|               "gap",
  526|  14.2k|               "ignored advertising field (type %#.2x)",
  527|  14.2k|               static_cast<unsigned int>(type));
  528|  14.2k|        break;
  529|   147k|    }
  530|   147k|    PW_MODIFY_DIAGNOSTICS_POP();
  531|   147k|  }
  532|       |
  533|  3.30k|  return fit::ok(std::move(out_ad));
  534|  3.60k|}
_ZN2bt15AdvertisingData14AddServiceUuidERKNS_4UUIDE:
  569|  20.2k|[[nodiscard]] bool AdvertisingData::AddServiceUuid(const UUID& uuid) {
  570|  20.2k|  auto iter = service_uuids_.find(uuid.CompactSize());
  571|  20.2k|  PW_CHECK(iter != service_uuids_.end());
  ------------------
  |  |   39|  20.2k|  do {                                                                         \
  |  |   40|  20.2k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 20.2k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  20.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  572|  20.2k|  BoundedUuids& uuids = iter->second;
  573|  20.2k|  return uuids.AddUuid(uuid);
  574|  20.2k|}
_ZN2bt15AdvertisingData14SetServiceDataERKNS_4UUIDERKNS_10ByteBufferE:
  585|  23.6k|                                                   const ByteBuffer& data) {
  586|  23.6k|  size_t encoded_size = EncodedServiceDataSize(uuid, data.view());
  587|  23.6k|  if (encoded_size > kMaxEncodedServiceDataLength) {
  ------------------
  |  Branch (587:7): [True: 0, False: 23.6k]
  ------------------
  588|      0|    bt_log(WARN,
  ------------------
  |  |  141|      0|  PW_LOG(static_cast<int>(bt::LogSeverity::level), \
  |  |  ------------------
  |  |  |  |   73|      0|  do {                                                                     \
  |  |  |  |   74|      0|    if (PW_LOG_ENABLE_IF(level, verbosity, module, flags)) {               \
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|      0|  ((int32_t)(level) >= (int32_t)(verbosity))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (43:3): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   75|      0|      PW_HANDLE_LOG(level, module, flags, __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|  do {                                                    \
  |  |  |  |  |  |   56|      0|    pw_Log((level),                                       \
  |  |  |  |  |  |   57|      0|           (flags),                                       \
  |  |  |  |  |  |   58|      0|           module,                                        \
  |  |  |  |  |  |   59|      0|           __FILE__,                                      \
  |  |  |  |  |  |   60|      0|           __LINE__,                                      \
  |  |  |  |  |  |   61|      0|           __func__,                                      \
  |  |  |  |  |  |   62|      0|           message PW_COMMA_ARGS(__VA_ARGS__));           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   57|      0|  _PW_IF(PW_EMPTY_ARGS(__VA_ARGS__), _PW_EXPAND, _PW_COMMA_ARGS) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   21|      0|  _PW_PASTE2(_PW_IF_, boolean)(true_expr, false_expr)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   27|      0|#define _PW_PASTE2(a1, a2) _PW_PASTE2_EXPANDED(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   28|      0|#define _PW_PASTE2_EXPANDED(a1, a2) _PW_PASTE2_IMPL(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   29|      0|#define _PW_PASTE2_IMPL(a1, a2) a1##a2
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   58|      0|  (PW_DROP_LAST_ARG_IF_EMPTY(__VA_ARGS__))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   76|      0|    }                                                                      \
  |  |  |  |   77|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (77:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  142|      0|         PW_LOG_LEVEL,                             \
  |  |  143|      0|         tag,                                      \
  |  |  144|      0|         GetPwLogFlags(bt::LogSeverity::level),    \
  |  |  145|      0|         __VA_ARGS__);                             \
  |  |  146|      0|  ::bt::internal::CheckFormat(tag)
  ------------------
  589|      0|           "gap-le",
  590|      0|           "SetServiceData for UUID %s failed: (UUID+data) size %zu > maximum "
  591|      0|           "allowed size %du",
  592|      0|           bt_str(uuid),
  593|      0|           encoded_size,
  594|      0|           kMaxEncodedServiceDataLength);
  595|      0|    return false;
  596|      0|  }
  597|  23.6k|  service_data_[uuid] = DynamicByteBuffer(data);
  598|  23.6k|  return true;
  599|  23.6k|}
_ZN2bt15AdvertisingData19AddSolicitationUuidERKNS_4UUIDE:
  616|  3.42k|[[nodiscard]] bool AdvertisingData::AddSolicitationUuid(const UUID& uuid) {
  617|  3.42k|  auto iter = solicitation_uuids_.find(uuid.CompactSize());
  618|  3.42k|  PW_CHECK(iter != solicitation_uuids_.end());
  ------------------
  |  |   39|  3.42k|  do {                                                                         \
  |  |   40|  3.42k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 3.42k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  3.42k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  619|  3.42k|  BoundedUuids& uuids = iter->second;
  620|  3.42k|  return uuids.AddUuid(uuid);
  621|  3.42k|}
_ZN2bt15AdvertisingData19SetManufacturerDataEtRKNS_10BufferViewE:
  632|  10.7k|    const uint16_t company_id, const BufferView& data) {
  633|  10.7k|  size_t field_size = data.size();
  634|  10.7k|  if (field_size > kMaxManufacturerDataLength) {
  ------------------
  |  Branch (634:7): [True: 0, False: 10.7k]
  ------------------
  635|      0|    bt_log(WARN,
  ------------------
  |  |  141|      0|  PW_LOG(static_cast<int>(bt::LogSeverity::level), \
  |  |  ------------------
  |  |  |  |   73|      0|  do {                                                                     \
  |  |  |  |   74|      0|    if (PW_LOG_ENABLE_IF(level, verbosity, module, flags)) {               \
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|      0|  ((int32_t)(level) >= (int32_t)(verbosity))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (43:3): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   75|      0|      PW_HANDLE_LOG(level, module, flags, __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|  do {                                                    \
  |  |  |  |  |  |   56|      0|    pw_Log((level),                                       \
  |  |  |  |  |  |   57|      0|           (flags),                                       \
  |  |  |  |  |  |   58|      0|           module,                                        \
  |  |  |  |  |  |   59|      0|           __FILE__,                                      \
  |  |  |  |  |  |   60|      0|           __LINE__,                                      \
  |  |  |  |  |  |   61|      0|           __func__,                                      \
  |  |  |  |  |  |   62|      0|           message PW_COMMA_ARGS(__VA_ARGS__));           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   57|      0|  _PW_IF(PW_EMPTY_ARGS(__VA_ARGS__), _PW_EXPAND, _PW_COMMA_ARGS) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   21|      0|  _PW_PASTE2(_PW_IF_, boolean)(true_expr, false_expr)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   27|      0|#define _PW_PASTE2(a1, a2) _PW_PASTE2_EXPANDED(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   28|      0|#define _PW_PASTE2_EXPANDED(a1, a2) _PW_PASTE2_IMPL(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   29|      0|#define _PW_PASTE2_IMPL(a1, a2) a1##a2
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   58|      0|  (PW_DROP_LAST_ARG_IF_EMPTY(__VA_ARGS__))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   76|      0|    }                                                                      \
  |  |  |  |   77|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (77:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  142|      0|         PW_LOG_LEVEL,                             \
  |  |  143|      0|         tag,                                      \
  |  |  144|      0|         GetPwLogFlags(bt::LogSeverity::level),    \
  |  |  145|      0|         __VA_ARGS__);                             \
  |  |  146|      0|  ::bt::internal::CheckFormat(tag)
  ------------------
  636|      0|           "gap-le",
  637|      0|           "SetManufacturerData for company id %#.4x failed: (UUID+data) size "
  638|      0|           "%zu > maximum allowed "
  639|      0|           "size %hhu",
  640|      0|           company_id,
  641|      0|           field_size,
  642|      0|           kMaxManufacturerDataLength);
  643|      0|    return false;
  644|      0|  }
  645|  10.7k|  manufacturer_data_[company_id] = DynamicByteBuffer(data);
  646|  10.7k|  return true;
  647|  10.7k|}
_ZN2bt15AdvertisingData10SetTxPowerEa:
  664|    573|void AdvertisingData::SetTxPower(int8_t dbm) { tx_power_ = dbm; }
_ZN2bt15AdvertisingData12SetLocalNameERKNS0_9LocalNameE:
  668|  22.1k|bool AdvertisingData::SetLocalName(const LocalName& local_name) {
  669|  22.1k|  if (local_name.name.size() > kMaxNameLength) {
  ------------------
  |  Branch (669:7): [True: 0, False: 22.1k]
  ------------------
  670|      0|    return false;
  671|      0|  }
  672|  22.1k|  if (local_name_.has_value() && local_name_->is_complete &&
  ------------------
  |  Branch (672:7): [True: 22.0k, False: 174]
  |  Branch (672:34): [True: 21.0k, False: 957]
  ------------------
  673|  22.1k|      !local_name.is_complete) {
  ------------------
  |  Branch (673:7): [True: 6.50k, False: 14.5k]
  ------------------
  674|  6.50k|    return false;
  675|  6.50k|  }
  676|  15.6k|  local_name_ = local_name;
  677|  15.6k|  return true;
  678|  22.1k|}
_ZN2bt15AdvertisingData26SetResolvableSetIdentifierENSt3__15arrayIhLm6EEE:
  685|    449|    std::array<uint8_t, kResolvableSetIdentifierSize> identifier) {
  686|    449|  resolvable_set_identifier_ = identifier;
  687|    449|}
_ZN2bt15AdvertisingData16SetBroadcastNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  694|  1.17k|void AdvertisingData::SetBroadcastName(const std::string& name) {
  695|  1.17k|  broadcast_name_ = name;
  696|  1.17k|}
_ZN2bt15AdvertisingData6AddUriERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  702|  39.7k|[[nodiscard]] bool AdvertisingData::AddUri(const std::string& uri) {
  703|  39.7k|  if (EncodeUri(uri).size() > kMaxEncodedUriLength) {
  ------------------
  |  Branch (703:7): [True: 0, False: 39.7k]
  ------------------
  704|      0|    bt_log(WARN,
  ------------------
  |  |  141|      0|  PW_LOG(static_cast<int>(bt::LogSeverity::level), \
  |  |  ------------------
  |  |  |  |   73|      0|  do {                                                                     \
  |  |  |  |   74|      0|    if (PW_LOG_ENABLE_IF(level, verbosity, module, flags)) {               \
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|      0|  ((int32_t)(level) >= (int32_t)(verbosity))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (43:3): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   75|      0|      PW_HANDLE_LOG(level, module, flags, __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|  do {                                                    \
  |  |  |  |  |  |   56|      0|    pw_Log((level),                                       \
  |  |  |  |  |  |   57|      0|           (flags),                                       \
  |  |  |  |  |  |   58|      0|           module,                                        \
  |  |  |  |  |  |   59|      0|           __FILE__,                                      \
  |  |  |  |  |  |   60|      0|           __LINE__,                                      \
  |  |  |  |  |  |   61|      0|           __func__,                                      \
  |  |  |  |  |  |   62|      0|           message PW_COMMA_ARGS(__VA_ARGS__));           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   57|      0|  _PW_IF(PW_EMPTY_ARGS(__VA_ARGS__), _PW_EXPAND, _PW_COMMA_ARGS) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   21|      0|  _PW_PASTE2(_PW_IF_, boolean)(true_expr, false_expr)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   27|      0|#define _PW_PASTE2(a1, a2) _PW_PASTE2_EXPANDED(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   28|      0|#define _PW_PASTE2_EXPANDED(a1, a2) _PW_PASTE2_IMPL(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   29|      0|#define _PW_PASTE2_IMPL(a1, a2) a1##a2
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   58|      0|  (PW_DROP_LAST_ARG_IF_EMPTY(__VA_ARGS__))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   76|      0|    }                                                                      \
  |  |  |  |   77|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (77:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  142|      0|         PW_LOG_LEVEL,                             \
  |  |  143|      0|         tag,                                      \
  |  |  144|      0|         GetPwLogFlags(bt::LogSeverity::level),    \
  |  |  145|      0|         __VA_ARGS__);                             \
  |  |  146|      0|  ::bt::internal::CheckFormat(tag)
  ------------------
  705|      0|           "gap-le",
  706|      0|           "not inserting uri %s as it exceeds the max URI size for AD",
  707|      0|           uri.c_str());
  708|      0|    return false;
  709|      0|  }
  710|  39.7k|  if (uri.empty()) {
  ------------------
  |  Branch (710:7): [True: 9.13k, False: 30.6k]
  ------------------
  711|  9.13k|    bt_log(WARN, "gap-le", "skipping insertion of empty uri to AD");
  ------------------
  |  |  141|  9.13k|  PW_LOG(static_cast<int>(bt::LogSeverity::level), \
  |  |  ------------------
  |  |  |  |   73|  9.13k|  do {                                                                     \
  |  |  |  |   74|  9.13k|    if (PW_LOG_ENABLE_IF(level, verbosity, module, flags)) {               \
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|  9.13k|  ((int32_t)(level) >= (int32_t)(verbosity))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (43:3): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   75|  9.13k|      PW_HANDLE_LOG(level, module, flags, __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|  9.13k|  do {                                                    \
  |  |  |  |  |  |   56|  9.13k|    pw_Log((level),                                       \
  |  |  |  |  |  |   57|  9.13k|           (flags),                                       \
  |  |  |  |  |  |   58|  9.13k|           module,                                        \
  |  |  |  |  |  |   59|  9.13k|           __FILE__,                                      \
  |  |  |  |  |  |   60|  9.13k|           __LINE__,                                      \
  |  |  |  |  |  |   61|  9.13k|           __func__,                                      \
  |  |  |  |  |  |   62|  9.13k|           message PW_COMMA_ARGS(__VA_ARGS__));           \
  |  |  |  |  |  |   63|  9.13k|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   76|  9.13k|    }                                                                      \
  |  |  |  |   77|  9.13k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (77:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  142|  9.13k|         PW_LOG_LEVEL,                             \
  |  |  143|  9.13k|         tag,                                      \
  |  |  144|  9.13k|         GetPwLogFlags(bt::LogSeverity::level),    \
  |  |  145|  9.13k|         __VA_ARGS__);                             \
  |  |  146|  9.13k|  ::bt::internal::CheckFormat(tag)
  ------------------
  712|  9.13k|    return true;
  713|  9.13k|  }
  714|  30.6k|  uris_.insert(uri);
  715|  30.6k|  return true;
  716|  39.7k|}
_ZN2bt15AdvertisingData13SetAppearanceEt:
  722|    380|void AdvertisingData::SetAppearance(uint16_t appearance) {
  723|    380|  appearance_ = appearance;
  724|    380|}
_ZN2bt15AdvertisingData8SetFlagsEh:
  730|  19.0k|void AdvertisingData::SetFlags(AdvFlags flags) { flags_ = flags; }
_ZNK2bt15AdvertisingData18CalculateBlockSizeEb:
  734|  3.30k|size_t AdvertisingData::CalculateBlockSize(bool include_flags) const {
  735|  3.30k|  size_t len = 0;
  736|  3.30k|  if (include_flags) {
  ------------------
  |  Branch (736:7): [True: 1.32k, False: 1.98k]
  ------------------
  737|  1.32k|    len += kTLVFlagsSize;
  738|  1.32k|  }
  739|       |
  740|  3.30k|  if (tx_power_) {
  ------------------
  |  Branch (740:7): [True: 16, False: 3.29k]
  ------------------
  741|     16|    len += kTLVTxPowerLevelSize;
  742|     16|  }
  743|       |
  744|  3.30k|  if (appearance_) {
  ------------------
  |  Branch (744:7): [True: 9, False: 3.29k]
  ------------------
  745|      9|    len += kTLVAppearanceSize;
  746|      9|  }
  747|       |
  748|  3.30k|  if (local_name_) {
  ------------------
  |  Branch (748:7): [True: 162, False: 3.14k]
  ------------------
  749|    162|    len += 2 + local_name_->name.size();
  750|    162|  }
  751|       |
  752|  4.08k|  for (const auto& manuf_pair : manufacturer_data_) {
  ------------------
  |  Branch (752:31): [True: 4.08k, False: 3.30k]
  ------------------
  753|  4.08k|    len += 2 + 2 + manuf_pair.second.size();
  754|  4.08k|  }
  755|       |
  756|  9.01k|  for (const auto& service_data_pair : service_data_) {
  ------------------
  |  Branch (756:38): [True: 9.01k, False: 3.30k]
  ------------------
  757|  9.01k|    len += 2 + service_data_pair.first.CompactSize() +
  758|  9.01k|           service_data_pair.second.size();
  759|  9.01k|  }
  760|       |
  761|  15.7k|  for (const auto& uri : uris_) {
  ------------------
  |  Branch (761:24): [True: 15.7k, False: 3.30k]
  ------------------
  762|  15.7k|    len += 2 + EncodeUri(uri).size();
  763|  15.7k|  }
  764|       |
  765|  9.92k|  for (const auto& [uuid_size, bounded_uuids] : service_uuids_) {
  ------------------
  |  Branch (765:47): [True: 9.92k, False: 3.30k]
  ------------------
  766|  9.92k|    if (bounded_uuids.set().empty()) {
  ------------------
  |  Branch (766:9): [True: 9.20k, False: 716]
  ------------------
  767|  9.20k|      continue;
  768|  9.20k|    }
  769|    716|    len += 2;  // 1 byte for # of UUIDs and 1 for UUID type
  770|    716|    len += uuid_size * bounded_uuids.set().size();
  771|    716|  }
  772|       |
  773|  9.92k|  for (const auto& [uuid_size, bounded_uuids] : solicitation_uuids_) {
  ------------------
  |  Branch (773:47): [True: 9.92k, False: 3.30k]
  ------------------
  774|  9.92k|    if (bounded_uuids.set().empty()) {
  ------------------
  |  Branch (774:9): [True: 9.73k, False: 191]
  ------------------
  775|  9.73k|      continue;
  776|  9.73k|    }
  777|    191|    len += 2;  // 1 byte for # of UUIDs and 1 for UUID type
  778|    191|    len += uuid_size * bounded_uuids.set().size();
  779|    191|  }
  780|       |
  781|  3.30k|  if (resolvable_set_identifier_.has_value()) {
  ------------------
  |  Branch (781:7): [True: 15, False: 3.29k]
  ------------------
  782|     15|    len += kTLVResolvableSetIdentifierSize;
  783|     15|  }
  784|       |
  785|  3.30k|  if (broadcast_name_) {
  ------------------
  |  Branch (785:7): [True: 64, False: 3.24k]
  ------------------
  786|     64|    len += 2 + broadcast_name_->size();
  787|     64|  }
  788|       |
  789|  3.30k|  return len;
  790|  3.30k|}
_ZNK2bt15AdvertisingData10WriteBlockEPNS_17MutableByteBufferENSt3__18optionalIhEE:
  793|  3.30k|                                 std::optional<AdvFlags> flags) const {
  794|  3.30k|  PW_DCHECK(buffer);
  ------------------
  |  |   51|  3.30k|  do {                            \
  |  |   52|  3.30k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |   53|  3.30k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  3.30k|  do {                                                                         \
  |  |  |  |   40|  3.30k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 3.30k]
  |  |  |  |  ------------------
  |  |  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |  |  |   45|      0|      }                                                                        \
  |  |  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   47|      0|    }                                                                          \
  |  |  |  |   48|  3.30k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  3.30k|    }                             \
  |  |   55|  3.30k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  795|       |
  796|  3.30k|  size_t min_buf_size = CalculateBlockSize(flags.has_value());
  797|  3.30k|  if (buffer->size() < min_buf_size) {
  ------------------
  |  Branch (797:7): [True: 599, False: 2.70k]
  ------------------
  798|    599|    return false;
  799|    599|  }
  800|       |
  801|  2.70k|  size_t pos = 0;
  802|  2.70k|  if (flags) {
  ------------------
  |  Branch (802:7): [True: 1.13k, False: 1.57k]
  ------------------
  803|  1.13k|    (*buffer)[pos++] =
  804|  1.13k|        kTLVFlagsSize - 1;  // size variable includes current field, subtract 1
  805|  1.13k|    (*buffer)[pos++] = static_cast<uint8_t>(DataType::kFlags);
  806|  1.13k|    (*buffer)[pos++] = static_cast<uint8_t>(flags.value());
  807|  1.13k|  }
  808|       |
  809|  2.70k|  if (tx_power_) {
  ------------------
  |  Branch (809:7): [True: 14, False: 2.69k]
  ------------------
  810|     14|    (*buffer)[pos++] = kTLVTxPowerLevelSize -
  811|     14|                       1;  // size variable includes current field, subtract 1
  812|     14|    (*buffer)[pos++] = static_cast<uint8_t>(DataType::kTxPowerLevel);
  813|     14|    (*buffer)[pos++] = static_cast<uint8_t>(tx_power_.value());
  814|     14|  }
  815|       |
  816|  2.70k|  if (appearance_) {
  ------------------
  |  Branch (816:7): [True: 9, False: 2.69k]
  ------------------
  817|      9|    (*buffer)[pos++] = kTLVAppearanceSize -
  818|      9|                       1;  // size variable includes current field, subtract 1
  819|      9|    (*buffer)[pos++] = static_cast<uint8_t>(DataType::kAppearance);
  820|      9|    pos += BufferWrite(buffer, pos, appearance_.value());
  821|      9|  }
  822|       |
  823|  2.70k|  if (local_name_) {
  ------------------
  |  Branch (823:7): [True: 117, False: 2.59k]
  ------------------
  824|    117|    PW_CHECK(local_name_->name.size() <= kMaxNameLength);
  ------------------
  |  |   39|    117|  do {                                                                         \
  |  |   40|    117|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 117]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|    117|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  825|    117|    (*buffer)[pos++] =
  826|    117|        static_cast<uint8_t>(local_name_->name.size()) + 1;  // 1 for null char
  827|    117|    (*buffer)[pos++] = static_cast<uint8_t>(DataType::kCompleteLocalName);
  828|    117|    buffer->Write(reinterpret_cast<const uint8_t*>(local_name_->name.c_str()),
  829|    117|                  local_name_->name.size(),
  830|    117|                  pos);
  831|    117|    pos += local_name_->name.size();
  832|    117|  }
  833|       |
  834|  2.70k|  for (const auto& manuf_pair : manufacturer_data_) {
  ------------------
  |  Branch (834:31): [True: 2.55k, False: 2.70k]
  ------------------
  835|  2.55k|    size_t data_size = manuf_pair.second.size();
  836|  2.55k|    PW_CHECK(data_size <= kMaxManufacturerDataLength);
  ------------------
  |  |   39|  2.55k|  do {                                                                         \
  |  |   40|  2.55k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 2.55k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  2.55k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  837|  2.55k|    (*buffer)[pos++] =
  838|  2.55k|        1 + 2 +
  839|  2.55k|        static_cast<uint8_t>(data_size);  // 1 for type, 2 for Manuf. Code
  840|  2.55k|    (*buffer)[pos++] =
  841|  2.55k|        static_cast<uint8_t>(DataType::kManufacturerSpecificData);
  842|  2.55k|    pos += BufferWrite(buffer, pos, manuf_pair.first);
  843|  2.55k|    buffer->Write(manuf_pair.second, pos);
  844|  2.55k|    pos += data_size;
  845|  2.55k|  }
  846|       |
  847|  4.79k|  for (const auto& service_data_pair : service_data_) {
  ------------------
  |  Branch (847:38): [True: 4.79k, False: 2.70k]
  ------------------
  848|  4.79k|    UUID uuid = service_data_pair.first;
  849|  4.79k|    size_t encoded_service_data_size =
  850|  4.79k|        EncodedServiceDataSize(uuid, service_data_pair.second.view());
  851|  4.79k|    PW_CHECK(encoded_service_data_size <= kMaxEncodedServiceDataLength);
  ------------------
  |  |   39|  4.79k|  do {                                                                         \
  |  |   40|  4.79k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 4.79k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  4.79k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  852|  4.79k|    (*buffer)[pos++] =
  853|  4.79k|        1 + static_cast<uint8_t>(encoded_service_data_size);  // 1 for type
  854|  4.79k|    (*buffer)[pos++] =
  855|  4.79k|        static_cast<uint8_t>(ServiceDataTypeForUuidSize(uuid.CompactSize()));
  856|  4.79k|    auto target = buffer->mutable_view(pos);
  857|  4.79k|    pos += service_data_pair.first.ToBytes(&target);
  858|  4.79k|    buffer->Write(service_data_pair.second, pos);
  859|  4.79k|    pos += service_data_pair.second.size();
  860|  4.79k|  }
  861|       |
  862|  4.61k|  for (const auto& uri : uris_) {
  ------------------
  |  Branch (862:24): [True: 4.61k, False: 2.70k]
  ------------------
  863|  4.61k|    std::string s = EncodeUri(uri);
  864|  4.61k|    PW_CHECK(s.size() <= kMaxEncodedUriLength);
  ------------------
  |  |   39|  4.61k|  do {                                                                         \
  |  |   40|  4.61k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 4.61k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  4.61k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  865|  4.61k|    (*buffer)[pos++] = 1 + static_cast<uint8_t>(s.size());  // 1 for type
  866|  4.61k|    (*buffer)[pos++] = static_cast<uint8_t>(DataType::kURI);
  867|  4.61k|    buffer->Write(reinterpret_cast<const uint8_t*>(s.c_str()), s.length(), pos);
  868|  4.61k|    pos += s.size();
  869|  4.61k|  }
  870|       |
  871|  8.12k|  for (const auto& [uuid_width, bounded_uuids] : service_uuids_) {
  ------------------
  |  Branch (871:48): [True: 8.12k, False: 2.70k]
  ------------------
  872|  8.12k|    if (bounded_uuids.set().empty()) {
  ------------------
  |  Branch (872:9): [True: 7.65k, False: 468]
  ------------------
  873|  7.65k|      continue;
  874|  7.65k|    }
  875|       |
  876|       |    // 1 for type
  877|    468|    PW_CHECK(1 + uuid_width * bounded_uuids.set().size() <=
  ------------------
  |  |   39|    468|  do {                                                                         \
  |  |   40|    468|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 468]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|    468|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  878|    468|             std::numeric_limits<uint8_t>::max());
  879|    468|    (*buffer)[pos++] =
  880|    468|        1 + uuid_width * static_cast<uint8_t>(bounded_uuids.set().size());
  881|    468|    (*buffer)[pos++] = static_cast<uint8_t>(
  882|    468|        ServiceUuidTypeForUuidSize(uuid_width, /*complete=*/false));
  883|  4.21k|    for (const auto& uuid : bounded_uuids.set()) {
  ------------------
  |  Branch (883:27): [True: 4.21k, False: 468]
  ------------------
  884|  4.21k|      PW_CHECK(uuid.CompactSize() == uuid_width,
  ------------------
  |  |   39|  4.21k|  do {                                                                         \
  |  |   40|  4.21k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 4.21k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  4.21k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  885|  4.21k|               "UUID: %s - Expected Width: %d",
  886|  4.21k|               bt_str(uuid),
  887|  4.21k|               uuid_width);
  888|  4.21k|      auto target = buffer->mutable_view(pos);
  889|  4.21k|      pos += uuid.ToBytes(&target);
  890|  4.21k|    }
  891|    468|  }
  892|       |
  893|  8.12k|  for (const auto& [uuid_width, bounded_uuids] : solicitation_uuids_) {
  ------------------
  |  Branch (893:48): [True: 8.12k, False: 2.70k]
  ------------------
  894|  8.12k|    if (bounded_uuids.set().empty()) {
  ------------------
  |  Branch (894:9): [True: 7.97k, False: 153]
  ------------------
  895|  7.97k|      continue;
  896|  7.97k|    }
  897|       |
  898|       |    // 1 for type
  899|    153|    PW_CHECK(1 + uuid_width * bounded_uuids.set().size() <=
  ------------------
  |  |   39|    153|  do {                                                                         \
  |  |   40|    153|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 153]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|    153|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  900|    153|             std::numeric_limits<uint8_t>::max());
  901|    153|    (*buffer)[pos++] =
  902|    153|        1 + uuid_width * static_cast<uint8_t>(bounded_uuids.set().size());
  903|    153|    (*buffer)[pos++] =
  904|    153|        static_cast<uint8_t>(SolicitationUuidTypeForUuidSize(uuid_width));
  905|  1.69k|    for (const auto& uuid : bounded_uuids.set()) {
  ------------------
  |  Branch (905:27): [True: 1.69k, False: 153]
  ------------------
  906|  1.69k|      PW_CHECK(uuid.CompactSize() == uuid_width,
  ------------------
  |  |   39|  1.69k|  do {                                                                         \
  |  |   40|  1.69k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 1.69k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  1.69k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  907|  1.69k|               "UUID: %s - Expected Width: %d",
  908|  1.69k|               bt_str(uuid),
  909|  1.69k|               uuid_width);
  910|  1.69k|      auto target = buffer->mutable_view(pos);
  911|  1.69k|      pos += uuid.ToBytes(&target);
  912|  1.69k|    }
  913|    153|  }
  914|       |
  915|  2.70k|  if (resolvable_set_identifier_) {
  ------------------
  |  Branch (915:7): [True: 14, False: 2.69k]
  ------------------
  916|     14|    (*buffer)[pos++] =
  917|     14|        1 +
  918|     14|        static_cast<uint8_t>(resolvable_set_identifier_->size());  // 1 for type
  919|     14|    (*buffer)[pos++] = static_cast<uint8_t>(DataType::kResolvableSetIdentifier);
  920|     14|    buffer->Write(resolvable_set_identifier_->data(),
  921|     14|                  resolvable_set_identifier_->size(),
  922|     14|                  pos);
  923|     14|    pos += resolvable_set_identifier_->size();
  924|     14|  }
  925|       |
  926|  2.70k|  if (broadcast_name_) {
  ------------------
  |  Branch (926:7): [True: 38, False: 2.67k]
  ------------------
  927|     38|    (*buffer)[pos++] =
  928|     38|        1 + static_cast<uint8_t>(broadcast_name_->size());  // 1 for type
  929|     38|    (*buffer)[pos++] = static_cast<uint8_t>(DataType::kBroadcastName);
  930|     38|    buffer->Write(reinterpret_cast<const uint8_t*>(broadcast_name_->c_str()),
  931|     38|                  broadcast_name_->size(),
  932|     38|                  pos);
  933|     38|    pos += broadcast_name_->size();
  934|     38|  }
  935|       |
  936|  2.70k|  return true;
  937|  2.70k|}
_ZN2bt15AdvertisingData12BoundedUuids7AddUuidENS_4UUIDE:
  993|  23.6k|bool AdvertisingData::BoundedUuids::AddUuid(UUID uuid) {
  994|  23.6k|  PW_CHECK(set_.size() <= bound_);
  ------------------
  |  |   39|  23.6k|  do {                                                                         \
  |  |   40|  23.6k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 23.6k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  23.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  995|  23.6k|  if (set_.size() < bound_) {
  ------------------
  |  Branch (995:7): [True: 22.2k, False: 1.41k]
  ------------------
  996|  22.2k|    if (!set_.insert(uuid).second) {
  ------------------
  |  Branch (996:9): [True: 9.44k, False: 12.7k]
  ------------------
  997|  9.44k|      bt_log(INFO,
  ------------------
  |  |  141|  9.44k|  PW_LOG(static_cast<int>(bt::LogSeverity::level), \
  |  |  ------------------
  |  |  |  |   73|  9.44k|  do {                                                                     \
  |  |  |  |   74|  9.44k|    if (PW_LOG_ENABLE_IF(level, verbosity, module, flags)) {               \
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|  9.44k|  ((int32_t)(level) >= (int32_t)(verbosity))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (43:3): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   75|  9.44k|      PW_HANDLE_LOG(level, module, flags, __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|  9.44k|  do {                                                    \
  |  |  |  |  |  |   56|  9.44k|    pw_Log((level),                                       \
  |  |  |  |  |  |   57|  9.44k|           (flags),                                       \
  |  |  |  |  |  |   58|  9.44k|           module,                                        \
  |  |  |  |  |  |   59|  9.44k|           __FILE__,                                      \
  |  |  |  |  |  |   60|  9.44k|           __LINE__,                                      \
  |  |  |  |  |  |   61|  9.44k|           __func__,                                      \
  |  |  |  |  |  |   62|  9.44k|           message PW_COMMA_ARGS(__VA_ARGS__));           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   57|  9.44k|  _PW_IF(PW_EMPTY_ARGS(__VA_ARGS__), _PW_EXPAND, _PW_COMMA_ARGS) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   21|  9.44k|  _PW_PASTE2(_PW_IF_, boolean)(true_expr, false_expr)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   27|  9.44k|#define _PW_PASTE2(a1, a2) _PW_PASTE2_EXPANDED(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   28|  9.44k|#define _PW_PASTE2_EXPANDED(a1, a2) _PW_PASTE2_IMPL(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   29|  9.44k|#define _PW_PASTE2_IMPL(a1, a2) a1##a2
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   58|  9.44k|  (PW_DROP_LAST_ARG_IF_EMPTY(__VA_ARGS__))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  9.44k|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   76|  9.44k|    }                                                                      \
  |  |  |  |   77|  9.44k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (77:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  142|  9.44k|         PW_LOG_LEVEL,                             \
  |  |  143|  9.44k|         tag,                                      \
  |  |  144|  9.44k|         GetPwLogFlags(bt::LogSeverity::level),    \
  |  |  145|  9.44k|         __VA_ARGS__);                             \
  |  |  146|  9.44k|  ::bt::internal::CheckFormat(tag)
  ------------------
  998|  9.44k|             "gap-le",
  999|  9.44k|             "Skipping addition of duplicate UUID %s to AD",
 1000|  9.44k|             bt_str(uuid));
 1001|  9.44k|    }
 1002|  22.2k|    return true;
 1003|  22.2k|  }
 1004|  1.41k|  if (set_.find(uuid) != set_.end()) {
  ------------------
  |  Branch (1004:7): [True: 1.24k, False: 164]
  ------------------
 1005|  1.24k|    bt_log(INFO,
  ------------------
  |  |  141|  1.24k|  PW_LOG(static_cast<int>(bt::LogSeverity::level), \
  |  |  ------------------
  |  |  |  |   73|  1.24k|  do {                                                                     \
  |  |  |  |   74|  1.24k|    if (PW_LOG_ENABLE_IF(level, verbosity, module, flags)) {               \
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|  1.24k|  ((int32_t)(level) >= (int32_t)(verbosity))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (43:3): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   75|  1.24k|      PW_HANDLE_LOG(level, module, flags, __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|  1.24k|  do {                                                    \
  |  |  |  |  |  |   56|  1.24k|    pw_Log((level),                                       \
  |  |  |  |  |  |   57|  1.24k|           (flags),                                       \
  |  |  |  |  |  |   58|  1.24k|           module,                                        \
  |  |  |  |  |  |   59|  1.24k|           __FILE__,                                      \
  |  |  |  |  |  |   60|  1.24k|           __LINE__,                                      \
  |  |  |  |  |  |   61|  1.24k|           __func__,                                      \
  |  |  |  |  |  |   62|  1.24k|           message PW_COMMA_ARGS(__VA_ARGS__));           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   57|  1.24k|  _PW_IF(PW_EMPTY_ARGS(__VA_ARGS__), _PW_EXPAND, _PW_COMMA_ARGS) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   21|  1.24k|  _PW_PASTE2(_PW_IF_, boolean)(true_expr, false_expr)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   27|  1.24k|#define _PW_PASTE2(a1, a2) _PW_PASTE2_EXPANDED(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   28|  1.24k|#define _PW_PASTE2_EXPANDED(a1, a2) _PW_PASTE2_IMPL(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   29|  1.24k|#define _PW_PASTE2_IMPL(a1, a2) a1##a2
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   58|  1.24k|  (PW_DROP_LAST_ARG_IF_EMPTY(__VA_ARGS__))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  1.24k|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   76|  1.24k|    }                                                                      \
  |  |  |  |   77|  1.24k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (77:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  142|  1.24k|         PW_LOG_LEVEL,                             \
  |  |  143|  1.24k|         tag,                                      \
  |  |  144|  1.24k|         GetPwLogFlags(bt::LogSeverity::level),    \
  |  |  145|  1.24k|         __VA_ARGS__);                             \
  |  |  146|  1.24k|  ::bt::internal::CheckFormat(tag)
  ------------------
 1006|  1.24k|           "gap-le",
 1007|  1.24k|           "Skipping addition of duplicate UUID %s to AD",
 1008|  1.24k|           bt_str(uuid));
 1009|  1.24k|    return true;
 1010|  1.24k|  }
 1011|  1.41k|  bt_log(WARN,
  ------------------
  |  |  141|    164|  PW_LOG(static_cast<int>(bt::LogSeverity::level), \
  |  |  ------------------
  |  |  |  |   73|    164|  do {                                                                     \
  |  |  |  |   74|    164|    if (PW_LOG_ENABLE_IF(level, verbosity, module, flags)) {               \
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|    164|  ((int32_t)(level) >= (int32_t)(verbosity))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (43:3): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   75|    164|      PW_HANDLE_LOG(level, module, flags, __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|    164|  do {                                                    \
  |  |  |  |  |  |   56|    164|    pw_Log((level),                                       \
  |  |  |  |  |  |   57|    164|           (flags),                                       \
  |  |  |  |  |  |   58|    164|           module,                                        \
  |  |  |  |  |  |   59|    164|           __FILE__,                                      \
  |  |  |  |  |  |   60|    164|           __LINE__,                                      \
  |  |  |  |  |  |   61|    164|           __func__,                                      \
  |  |  |  |  |  |   62|    164|           message PW_COMMA_ARGS(__VA_ARGS__));           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   57|    164|  _PW_IF(PW_EMPTY_ARGS(__VA_ARGS__), _PW_EXPAND, _PW_COMMA_ARGS) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   21|    164|  _PW_PASTE2(_PW_IF_, boolean)(true_expr, false_expr)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   27|    164|#define _PW_PASTE2(a1, a2) _PW_PASTE2_EXPANDED(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   28|    164|#define _PW_PASTE2_EXPANDED(a1, a2) _PW_PASTE2_IMPL(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   29|    164|#define _PW_PASTE2_IMPL(a1, a2) a1##a2
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   58|    164|  (PW_DROP_LAST_ARG_IF_EMPTY(__VA_ARGS__))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    164|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   76|    164|    }                                                                      \
  |  |  |  |   77|    164|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (77:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  142|    164|         PW_LOG_LEVEL,                             \
  |  |  143|    164|         tag,                                      \
  |  |  144|    164|         GetPwLogFlags(bt::LogSeverity::level),    \
  |  |  145|    164|         __VA_ARGS__);                             \
  |  |  146|    164|  ::bt::internal::CheckFormat(tag)
  ------------------
 1012|    164|         "gap-le",
 1013|    164|         "Failed to add UUID %s to AD - no space left",
 1014|    164|         bt_str(uuid));
 1015|    164|  return false;
 1016|  1.41k|}
advertising_data.cc:_ZN2bt12_GLOBAL__N_19DecodeUriERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  137|  39.7k|std::string DecodeUri(const std::string& uri) {
  138|  39.7k|  if (uri[0] == kUndefinedScheme) {
  ------------------
  |  Branch (138:7): [True: 3.05k, False: 36.6k]
  ------------------
  139|  3.05k|    return uri.substr(1);
  140|  3.05k|  }
  141|       |
  142|       |  // NOTE: as we are reading UTF-8 from `uri`, it is possible that `code_point`
  143|       |  // corresponds to > 1 byte of `uri` (even for valid URI encoding schemes, as
  144|       |  // U+00(>7F) encodes to 2 bytes).
  145|  36.6k|  const auto result = pw::utf8::ReadCodePoint(uri);
  146|  36.6k|  if (!result.ok()) {
  ------------------
  |  Branch (146:7): [True: 8.18k, False: 28.5k]
  ------------------
  147|  8.18k|    bt_log(INFO,
  ------------------
  |  |  141|  8.18k|  PW_LOG(static_cast<int>(bt::LogSeverity::level), \
  |  |  ------------------
  |  |  |  |   73|  8.18k|  do {                                                                     \
  |  |  |  |   74|  8.18k|    if (PW_LOG_ENABLE_IF(level, verbosity, module, flags)) {               \
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|  8.18k|  ((int32_t)(level) >= (int32_t)(verbosity))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (43:3): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   75|  8.18k|      PW_HANDLE_LOG(level, module, flags, __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|  8.18k|  do {                                                    \
  |  |  |  |  |  |   56|  8.18k|    pw_Log((level),                                       \
  |  |  |  |  |  |   57|  8.18k|           (flags),                                       \
  |  |  |  |  |  |   58|  8.18k|           module,                                        \
  |  |  |  |  |  |   59|  8.18k|           __FILE__,                                      \
  |  |  |  |  |  |   60|  8.18k|           __LINE__,                                      \
  |  |  |  |  |  |   61|  8.18k|           __func__,                                      \
  |  |  |  |  |  |   62|  8.18k|           message PW_COMMA_ARGS(__VA_ARGS__));           \
  |  |  |  |  |  |   63|  8.18k|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   76|  8.18k|    }                                                                      \
  |  |  |  |   77|  8.18k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (77:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  142|  8.18k|         PW_LOG_LEVEL,                             \
  |  |  143|  8.18k|         tag,                                      \
  |  |  144|  8.18k|         GetPwLogFlags(bt::LogSeverity::level),    \
  |  |  145|  8.18k|         __VA_ARGS__);                             \
  |  |  146|  8.18k|  ::bt::internal::CheckFormat(tag)
  ------------------
  148|  8.18k|           "gap-le",
  149|  8.18k|           "Attempted to decode malformed UTF-8 in AdvertisingData URI");
  150|  8.18k|    return "";
  151|  8.18k|  }
  152|  28.5k|  const uint32_t code_point = result->code_point();
  153|       |  // `uri` is not a c-string, so URIs that start with '\0' after c_str
  154|       |  // conversion (i.e. both empty URIs and URIs with leading null bytes '\0') are
  155|       |  // caught by the code_point < 2 check. We check
  156|       |  // "< 2" instead of "== 0" for redundancy (extra safety!) with the
  157|       |  // kUndefinedScheme check above.
  158|  28.5k|  if (code_point >= kUriSchemesSize + 2 || code_point < 2) {
  ------------------
  |  Branch (158:7): [True: 459, False: 28.0k]
  |  Branch (158:44): [True: 295, False: 27.7k]
  ------------------
  159|    754|    bt_log(
  ------------------
  |  |  141|    754|  PW_LOG(static_cast<int>(bt::LogSeverity::level), \
  |  |  ------------------
  |  |  |  |   73|    754|  do {                                                                     \
  |  |  |  |   74|    754|    if (PW_LOG_ENABLE_IF(level, verbosity, module, flags)) {               \
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|    754|  ((int32_t)(level) >= (int32_t)(verbosity))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (43:3): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   75|    754|      PW_HANDLE_LOG(level, module, flags, __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|    754|  do {                                                    \
  |  |  |  |  |  |   56|    754|    pw_Log((level),                                       \
  |  |  |  |  |  |   57|    754|           (flags),                                       \
  |  |  |  |  |  |   58|    754|           module,                                        \
  |  |  |  |  |  |   59|    754|           __FILE__,                                      \
  |  |  |  |  |  |   60|    754|           __LINE__,                                      \
  |  |  |  |  |  |   61|    754|           __func__,                                      \
  |  |  |  |  |  |   62|    754|           message PW_COMMA_ARGS(__VA_ARGS__));           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   57|    754|  _PW_IF(PW_EMPTY_ARGS(__VA_ARGS__), _PW_EXPAND, _PW_COMMA_ARGS) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   21|    754|  _PW_PASTE2(_PW_IF_, boolean)(true_expr, false_expr)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   27|    754|#define _PW_PASTE2(a1, a2) _PW_PASTE2_EXPANDED(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   28|    754|#define _PW_PASTE2_EXPANDED(a1, a2) _PW_PASTE2_IMPL(a1, a2)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   29|    754|#define _PW_PASTE2_IMPL(a1, a2) a1##a2
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   58|    754|  (PW_DROP_LAST_ARG_IF_EMPTY(__VA_ARGS__))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    754|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   76|    754|    }                                                                      \
  |  |  |  |   77|    754|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (77:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  142|    754|         PW_LOG_LEVEL,                             \
  |  |  143|    754|         tag,                                      \
  |  |  144|    754|         GetPwLogFlags(bt::LogSeverity::level),    \
  |  |  145|    754|         __VA_ARGS__);                             \
  |  |  146|    754|  ::bt::internal::CheckFormat(tag)
  ------------------
  160|    754|        ERROR,
  161|    754|        "gap-le",
  162|    754|        "Failed to decode URI - supplied UTF-8 encoding scheme codepoint %u "
  163|    754|        "must be in the "
  164|    754|        "range 2-kUriSchemesSize + 1 (2-%zu) to correspond to a URI encoding",
  165|    754|        code_point,
  166|    754|        kUriSchemesSize + 1);
  167|    754|    return "";
  168|    754|  }
  169|  27.7k|  return kUriSchemes[code_point - 2] + uri.substr(result->size());
  170|  28.5k|}
advertising_data.cc:_ZN2bt12_GLOBAL__N_122EncodedServiceDataSizeERKNS_4UUIDENS_10BufferViewE:
   84|  28.4k|size_t EncodedServiceDataSize(const UUID& uuid, const BufferView data) {
   85|  28.4k|  return uuid.CompactSize() + data.size();
   86|  28.4k|}
advertising_data.cc:_ZN2bt12_GLOBAL__N_19EncodeUriERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  117|  60.0k|std::string EncodeUri(const std::string& uri) {
  118|  4.96M|  for (uint32_t i = 0; i < kUriSchemesSize; i++) {
  ------------------
  |  Branch (118:24): [True: 4.94M, False: 14.4k]
  ------------------
  119|  4.94M|    const char* scheme = kUriSchemes[i];
  120|  4.94M|    size_t scheme_len = strlen(scheme);
  121|  4.94M|    if (std::strncmp(uri.c_str(), scheme, scheme_len) == 0) {
  ------------------
  |  Branch (121:9): [True: 45.5k, False: 4.90M]
  ------------------
  122|  45.5k|      const pw::Result<pw::utf8::EncodedCodePoint> encoded_scheme =
  123|  45.5k|          pw::utf8::EncodeCodePoint(i + 2);
  124|  45.5k|      PW_DCHECK(encoded_scheme.ok());
  ------------------
  |  |   51|  45.5k|  do {                            \
  |  |   52|  45.5k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |   53|  45.5k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  45.5k|  do {                                                                         \
  |  |  |  |   40|  45.5k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 45.5k]
  |  |  |  |  ------------------
  |  |  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |  |  |   45|      0|      }                                                                        \
  |  |  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   47|      0|    }                                                                          \
  |  |  |  |   48|  45.5k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  45.5k|    }                             \
  |  |   55|  45.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  125|  45.5k|      return std::string(encoded_scheme->as_view()) + uri.substr(scheme_len);
  126|  45.5k|    }
  127|  4.94M|  }
  128|       |  // First codepoint (U+0001) is for uncompressed schemes.
  129|  14.4k|  const pw::Result<pw::utf8::EncodedCodePoint> encoded_scheme =
  130|  14.4k|      pw::utf8::EncodeCodePoint(1u);
  131|  14.4k|  PW_DCHECK(encoded_scheme.ok());
  ------------------
  |  |   51|  14.4k|  do {                            \
  |  |   52|  14.4k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |   53|  14.4k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  14.4k|  do {                                                                         \
  |  |  |  |   40|  14.4k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |  |  |   45|      0|      }                                                                        \
  |  |  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   47|      0|    }                                                                          \
  |  |  |  |   48|  14.4k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  14.4k|    }                             \
  |  |   55|  14.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  132|  14.4k|  return std::string(encoded_scheme->as_view()) + uri;
  133|  14.4k|}
advertising_data.cc:_ZN2bt12_GLOBAL__N_126ServiceDataTypeForUuidSizeENS_12UUIDElemSizeE:
   53|  4.79k|DataType ServiceDataTypeForUuidSize(UUIDElemSize size) {
   54|  4.79k|  switch (size) {
   55|  2.45k|    case UUIDElemSize::k16Bit:
  ------------------
  |  Branch (55:5): [True: 2.45k, False: 2.34k]
  ------------------
   56|  2.45k|      return DataType::kServiceData16Bit;
   57|  1.70k|    case UUIDElemSize::k32Bit:
  ------------------
  |  Branch (57:5): [True: 1.70k, False: 3.08k]
  ------------------
   58|  1.70k|      return DataType::kServiceData32Bit;
   59|    631|    case UUIDElemSize::k128Bit:
  ------------------
  |  Branch (59:5): [True: 631, False: 4.16k]
  ------------------
   60|    631|      return DataType::kServiceData128Bit;
   61|      0|    default:
  ------------------
  |  Branch (61:5): [True: 0, False: 4.79k]
  ------------------
   62|      0|      PW_CRASH(
  ------------------
  |  |   30|      0|  do {                                                                       \
  |  |   31|      0|    if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (31:9): [Folded - Ignored]
  |  |  ------------------
  |  |   32|      0|      _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   33|      0|    }                                                                        \
  |  |   34|      0|    PW_HANDLE_CRASH(__VA_ARGS__);                                            \
  |  |  ------------------
  |  |  |  |   23|      0|  PW_ASSERT_PRINT_EXPRESSION("CRASH", "PW_CRASH()"); \
  |  |  |  |   24|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (35:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   63|  4.79k|          "called ServiceDataTypeForUuidSize with unknown UUIDElemSize %du",
   64|  4.79k|          size);
   65|  4.79k|  };
   66|      0|}
advertising_data.cc:_ZN2bt12_GLOBAL__N_126ServiceUuidTypeForUuidSizeENS_12UUIDElemSizeEb:
   35|    468|DataType ServiceUuidTypeForUuidSize(UUIDElemSize size, bool complete) {
   36|    468|  switch (size) {
   37|    132|    case UUIDElemSize::k16Bit:
  ------------------
  |  Branch (37:5): [True: 132, False: 336]
  ------------------
   38|    132|      return complete ? DataType::kComplete16BitServiceUuids
  ------------------
  |  Branch (38:14): [True: 0, False: 132]
  ------------------
   39|    132|                      : DataType::kIncomplete16BitServiceUuids;
   40|    170|    case UUIDElemSize::k32Bit:
  ------------------
  |  Branch (40:5): [True: 170, False: 298]
  ------------------
   41|    170|      return complete ? DataType::kComplete32BitServiceUuids
  ------------------
  |  Branch (41:14): [True: 0, False: 170]
  ------------------
   42|    170|                      : DataType::kIncomplete32BitServiceUuids;
   43|    166|    case UUIDElemSize::k128Bit:
  ------------------
  |  Branch (43:5): [True: 166, False: 302]
  ------------------
   44|    166|      return complete ? DataType::kComplete128BitServiceUuids
  ------------------
  |  Branch (44:14): [True: 0, False: 166]
  ------------------
   45|    166|                      : DataType::kIncomplete128BitServiceUuids;
   46|      0|    default:
  ------------------
  |  Branch (46:5): [True: 0, False: 468]
  ------------------
   47|      0|      PW_CRASH(
  ------------------
  |  |   30|      0|  do {                                                                       \
  |  |   31|      0|    if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (31:9): [Folded - Ignored]
  |  |  ------------------
  |  |   32|      0|      _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   33|      0|    }                                                                        \
  |  |   34|      0|    PW_HANDLE_CRASH(__VA_ARGS__);                                            \
  |  |  ------------------
  |  |  |  |   23|      0|  PW_ASSERT_PRINT_EXPRESSION("CRASH", "PW_CRASH()"); \
  |  |  |  |   24|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (35:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   48|    468|          "called ServiceUuidTypeForUuidSize with unknown UUIDElemSize %du",
   49|    468|          size);
   50|    468|  }
   51|    468|}
advertising_data.cc:_ZN2bt12_GLOBAL__N_131SolicitationUuidTypeForUuidSizeENS_12UUIDElemSizeE:
   68|    153|DataType SolicitationUuidTypeForUuidSize(UUIDElemSize size) {
   69|    153|  switch (size) {
   70|     97|    case UUIDElemSize::k16Bit:
  ------------------
  |  Branch (70:5): [True: 97, False: 56]
  ------------------
   71|     97|      return DataType::kSolicitationUuid16Bit;
   72|     35|    case UUIDElemSize::k32Bit:
  ------------------
  |  Branch (72:5): [True: 35, False: 118]
  ------------------
   73|     35|      return DataType::kSolicitationUuid32Bit;
   74|     21|    case UUIDElemSize::k128Bit:
  ------------------
  |  Branch (74:5): [True: 21, False: 132]
  ------------------
   75|     21|      return DataType::kSolicitationUuid128Bit;
   76|      0|    default:
  ------------------
  |  Branch (76:5): [True: 0, False: 153]
  ------------------
   77|      0|      PW_CRASH(
  ------------------
  |  |   30|      0|  do {                                                                       \
  |  |   31|      0|    if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (31:9): [Folded - Ignored]
  |  |  ------------------
  |  |   32|      0|      _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   33|      0|    }                                                                        \
  |  |   34|      0|    PW_HANDLE_CRASH(__VA_ARGS__);                                            \
  |  |  ------------------
  |  |  |  |   23|      0|  PW_ASSERT_PRINT_EXPRESSION("CRASH", "PW_CRASH()"); \
  |  |  |  |   24|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (35:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   78|    153|          "called SolicitationUuidTypeForUuidSize with unknown UUIDElemSize "
   79|    153|          "%du",
   80|    153|          size);
   81|    153|  };
   82|      0|}
advertising_data.cc:_ZN2bt12_GLOBAL__N_111BufferWriteItEEmPNS_17MutableByteBufferEmRKT_:
  173|  2.56k|inline size_t BufferWrite(MutableByteBuffer* buffer, size_t pos, const T& var) {
  174|  2.56k|  buffer->Write((const uint8_t*)(uintptr_t)(&var), sizeof(T), pos);
  175|  2.56k|  return sizeof(T);
  176|  2.56k|}

_ZN2bt6common4fuzzEPKhm:
   22|  3.62k|void fuzz(const uint8_t* data, size_t size) {
   23|  3.62k|  FuzzedDataProvider fuzzed_data(data, size);
   24|  3.62k|  auto adv_flags = fuzzed_data.ConsumeIntegral<AdvFlags>();
   25|  3.62k|  bool include_adv_flags = fuzzed_data.ConsumeBool();
   26|  3.62k|  auto write_buffer_size = fuzzed_data.ConsumeIntegralInRange(0, 2000);
   27|  3.62k|  auto adv_data = fuzzed_data.ConsumeRemainingBytes<uint8_t>();
   28|       |
   29|  3.62k|  AdvertisingData::ParseResult result =
   30|  3.62k|      AdvertisingData::FromBytes(BufferView(adv_data));
   31|       |
   32|  3.62k|  if (result.is_ok()) {
  ------------------
  |  Branch (32:7): [True: 3.30k, False: 321]
  ------------------
   33|  3.30k|    DynamicByteBuffer write_buffer(write_buffer_size);
   34|  3.30k|    result->WriteBlock(
   35|  3.30k|        &write_buffer,
   36|  3.30k|        include_adv_flags ? std::optional(adv_flags) : std::nullopt);
  ------------------
  |  Branch (36:9): [True: 1.32k, False: 1.98k]
  ------------------
   37|  3.30k|  }
   38|  3.62k|}
LLVMFuzzerTestOneInput:
   42|  3.62k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   43|  3.62k|  bt::common::fuzz(data, size);
   44|  3.62k|  return 0;
   45|  3.62k|}

_ZNK2bt10ByteBuffer4CopyEPNS_17MutableByteBufferE:
   25|  59.7k|void ByteBuffer::Copy(MutableByteBuffer* out_buffer) const {
   26|  59.7k|  PW_CHECK(out_buffer);
  ------------------
  |  |   39|  59.7k|  do {                                                                         \
  |  |   40|  59.7k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 59.7k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  59.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   27|  59.7k|  CopyRaw(out_buffer->mutable_data(), out_buffer->size(), 0, size());
   28|  59.7k|}
_ZNK2bt10ByteBuffer4viewEmm:
   60|   567k|BufferView ByteBuffer::view(size_t pos, size_t size) const {
   61|   567k|  PW_CHECK(pos <= this->size(),
  ------------------
  |  |   39|   567k|  do {                                                                         \
  |  |   40|   567k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 567k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|   567k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   62|   567k|           "offset past buffer (pos: %zu, size: %zu)",
   63|   567k|           pos,
   64|   567k|           this->size());
   65|   567k|  return BufferView(data() + pos, std::min(size, this->size() - pos));
   66|   567k|}
_ZNK2bt10ByteBuffer8AsStringEv:
   77|  85.2k|std::string_view ByteBuffer::AsString() const {
   78|  85.2k|  return std::string_view(reinterpret_cast<const char*>(data()), size());
   79|  85.2k|}
_ZNK2bt10ByteBuffer8ToStringEb:
   93|  85.2k|std::string ByteBuffer::ToString(bool as_hex) const {
   94|  85.2k|  if (as_hex) {
  ------------------
  |  Branch (94:7): [True: 0, False: 85.2k]
  ------------------
   95|      0|    return AsHexadecimal();
   96|      0|  }
   97|  85.2k|  return std::string(AsString());
   98|  85.2k|}
_ZNK2bt10ByteBuffer7CopyRawEPvmmm:
  110|  60.1k|                         size_t copy_size) const {
  111|  60.1k|  PW_CHECK(copy_size == 0 || dst_data != nullptr,
  ------------------
  |  |   39|  60.1k|  do {                                                                         \
  |  |   40|   100k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:11): [True: 19.8k, False: 40.2k]
  |  |  |  Branch (40:11): [True: 40.2k, False: 0]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  60.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  112|  60.1k|           "%zu byte write to pointer %p",
  113|  60.1k|           copy_size,
  114|  60.1k|           dst_data);
  115|  60.1k|  PW_CHECK(copy_size <= dst_capacity,
  ------------------
  |  |   39|  60.1k|  do {                                                                         \
  |  |   40|  60.1k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 60.1k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  60.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|  60.1k|           "destination not large enough (required: %zu, available: %zu)",
  117|  60.1k|           copy_size,
  118|  60.1k|           dst_capacity);
  119|  60.1k|  PW_CHECK(src_offset <= this->size(),
  ------------------
  |  |   39|  60.1k|  do {                                                                         \
  |  |   40|  60.1k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 60.1k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  60.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  120|  60.1k|           "offset exceeds source range (begin: %zu, copy_size: %zu)",
  121|  60.1k|           src_offset,
  122|  60.1k|           this->size());
  123|  60.1k|  PW_CHECK(
  ------------------
  |  |   39|  60.1k|  do {                                                                         \
  |  |   40|  60.1k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 60.1k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  60.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  124|  60.1k|      std::numeric_limits<size_t>::max() - copy_size >= src_offset,
  125|  60.1k|      "end of source range overflows size_t (src_offset: %zu, copy_size: %zu)",
  126|  60.1k|      src_offset,
  127|  60.1k|      copy_size);
  128|  60.1k|  PW_CHECK(src_offset + copy_size <= this->size(),
  ------------------
  |  |   39|  60.1k|  do {                                                                         \
  |  |   40|  60.1k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 60.1k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  60.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  129|  60.1k|           "end exceeds source range (end: %zu, copy_size: %zu)",
  130|  60.1k|           src_offset + copy_size,
  131|  60.1k|           this->size());
  132|       |
  133|       |  // Data pointers for zero-length buffers are nullptr, over which memcpy has
  134|       |  // undefined behavior, even for count = 0. Skip the memcpy invocation in that
  135|       |  // case.
  136|  60.1k|  if (copy_size == 0) {
  ------------------
  |  Branch (136:7): [True: 19.8k, False: 40.2k]
  ------------------
  137|  19.8k|    return;
  138|  19.8k|  }
  139|  40.2k|  std::memcpy(dst_data, data() + src_offset, copy_size);
  140|  40.2k|}
_ZN2bt17MutableByteBuffer5WriteEPKhmm:
  142|  25.4k|void MutableByteBuffer::Write(const uint8_t* data, size_t size, size_t pos) {
  143|  25.4k|  BufferView from(data, size);
  144|  25.4k|  MutableBufferView to = mutable_view(pos);
  145|  25.4k|  from.Copy(&to);
  146|  25.4k|}
_ZN2bt17MutableByteBuffer12mutable_viewEmm:
  148|  36.1k|MutableBufferView MutableByteBuffer::mutable_view(size_t pos, size_t size) {
  149|  36.1k|  PW_CHECK(pos <= this->size(),
  ------------------
  |  |   39|  36.1k|  do {                                                                         \
  |  |   40|  36.1k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 36.1k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  36.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  150|  36.1k|           "offset past buffer (pos: %zu, size: %zu)",
  151|  36.1k|           pos,
  152|  36.1k|           this->size());
  153|  36.1k|  return MutableBufferView(mutable_data() + pos,
  154|  36.1k|                           std::min(size, this->size() - pos));
  155|  36.1k|}
_ZN2bt17DynamicByteBufferC2Ev:
  167|  13.5k|DynamicByteBuffer::DynamicByteBuffer() = default;
_ZN2bt17DynamicByteBufferC2Em:
  170|  3.30k|    : buffer_size_(buffer_size) {
  171|  3.30k|  if (buffer_size == 0) {
  ------------------
  |  Branch (171:7): [True: 427, False: 2.88k]
  ------------------
  172|    427|    return;
  173|    427|  }
  174|       |
  175|       |  // make_unique value-initializes the buffer to 0.
  176|  2.88k|  buffer_ = std::make_unique<uint8_t[]>(buffer_size);
  177|       |
  178|       |  // TODO(armansito): For now this is dumb but we should properly handle the
  179|       |  // case when we're out of memory.
  180|  2.88k|  PW_CHECK(buffer_.get(), "failed to allocate buffer");
  ------------------
  |  |   39|  2.88k|  do {                                                                         \
  |  |   40|  2.88k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 2.88k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  2.88k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  181|  2.88k|}
_ZN2bt17DynamicByteBufferC2ERKNS_10ByteBufferE:
  184|  34.3k|    : buffer_size_(buffer.size()),
  185|  34.3k|      buffer_(buffer.size() ? std::make_unique<uint8_t[]>(buffer.size())
  ------------------
  |  Branch (185:15): [True: 21.1k, False: 13.1k]
  ------------------
  186|  34.3k|                            : nullptr) {
  187|  34.3k|  PW_CHECK(!buffer_size_ || buffer_.get(),
  ------------------
  |  |   39|  34.3k|  do {                                                                         \
  |  |   40|  55.5k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:11): [True: 13.1k, False: 21.1k]
  |  |  |  Branch (40:11): [True: 21.1k, False: 0]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  34.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  188|  34.3k|           "|buffer| cannot be nullptr when |buffer_size| is non-zero");
  189|  34.3k|  buffer.Copy(this);
  190|  34.3k|}
_ZN2bt17DynamicByteBufferaSEOS0_:
  214|  34.3k|DynamicByteBuffer& DynamicByteBuffer::operator=(DynamicByteBuffer&& other) {
  215|  34.3k|  buffer_size_ = other.buffer_size_;
  216|  34.3k|  other.buffer_size_ = 0u;
  217|  34.3k|  buffer_ = std::move(other.buffer_);
  218|  34.3k|  return *this;
  219|  34.3k|}
_ZNK2bt17DynamicByteBuffer4dataEv:
  221|  12.1k|const uint8_t* DynamicByteBuffer::data() const { return buffer_.get(); }
_ZN2bt17DynamicByteBuffer12mutable_dataEv:
  223|  88.7k|uint8_t* DynamicByteBuffer::mutable_data() { return buffer_.get(); }
_ZNK2bt17DynamicByteBuffer4sizeEv:
  225|   154k|size_t DynamicByteBuffer::size() const { return buffer_size_; }
_ZN2bt10BufferViewC2ERKNS_10ByteBufferEm:
  264|  3.62k|BufferView::BufferView(const ByteBuffer& buffer, size_t size) {
  265|  3.62k|  *this = buffer.view(0u, size);
  266|  3.62k|}
_ZN2bt10BufferViewC2ERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  274|  3.62k|    : BufferView(vec.data(), vec.size()) {}
_ZN2bt10BufferViewC2EPKvm:
  280|   678k|    : size_(size), bytes_(static_cast<const uint8_t*>(bytes)) {
  281|       |  // If |size| non-zero then |bytes| cannot be nullptr.
  282|   678k|  PW_CHECK(!size_ || bytes_, "|bytes_| cannot be nullptr if |size_| > 0");
  ------------------
  |  |   39|   678k|  do {                                                                         \
  |  |   40|  1.27M|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:11): [True: 77.6k, False: 600k]
  |  |  |  Branch (40:11): [True: 600k, False: 0]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|   678k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  283|   678k|}
_ZN2bt10BufferViewC2Ev:
  285|  3.60k|BufferView::BufferView() = default;
_ZNK2bt10BufferView4dataEv:
  287|  1.52M|const uint8_t* BufferView::data() const { return bytes_; }
_ZNK2bt10BufferView4sizeEv:
  289|  3.32M|size_t BufferView::size() const { return size_; }
_ZN2bt17MutableBufferViewC2EPvm:
  302|  36.1k|    : size_(size), bytes_(static_cast<uint8_t*>(bytes)) {
  303|       |  // If |size| non-zero then |bytes| cannot be nullptr.
  304|  36.1k|  PW_CHECK(!size_ || bytes_, "|bytes_| cannot be nullptr if |size_| > 0");
  ------------------
  |  |   39|  36.1k|  do {                                                                         \
  |  |   40|  72.2k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:11): [True: 10, False: 36.0k]
  |  |  |  Branch (40:11): [True: 36.0k, False: 0]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  36.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  305|  36.1k|}
_ZNK2bt17MutableBufferView4sizeEv:
  311|  46.8k|size_t MutableBufferView::size() const { return size_; }
_ZN2bt17MutableBufferView12mutable_dataEv:
  319|  36.1k|uint8_t* MutableBufferView::mutable_data() { return bytes_; }

_ZN2bt13GetPwLogFlagsENS_11LogSeverityE:
   46|  43.1k|unsigned int GetPwLogFlags(LogSeverity level) {
   47|  43.1k|  if (g_printf_min_severity == -1) {
  ------------------
  |  Branch (47:7): [True: 43.1k, False: 0]
  ------------------
   48|  43.1k|    return 0;
   49|  43.1k|  }
   50|      0|  return IsPrintfLogLevelEnabled(level) ? PW_LOG_FLAG_USE_PRINTF
  ------------------
  |  |   26|      0|#define PW_LOG_FLAG_USE_PRINTF 0
  ------------------
  |  Branch (50:10): [True: 0, False: 0]
  ------------------
   51|      0|                                        : PW_LOG_FLAG_IGNORE;
  ------------------
  |  |   31|      0|#define PW_LOG_FLAG_IGNORE 0
  ------------------
   52|  43.1k|}

_ZN2bt10ParseUuidsERKNS_10BufferViewENS_12UUIDElemSizeEN3fit13function_implILm16ELb0EFbRKNS_4UUIDEENSt3__19allocatorISt4byteEEEE:
   26|  15.3k|                UuidFunction func) {
   27|  15.3k|  PW_CHECK(func);
  ------------------
  |  |   39|  15.3k|  do {                                                                         \
  |  |   40|  15.3k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 15.3k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|    }                                                                          \
  |  |   48|  15.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   28|       |
   29|  15.3k|  if (data.size() % uuid_size) {
  ------------------
  |  Branch (29:7): [True: 31, False: 15.2k]
  ------------------
   30|     31|    return false;
   31|     31|  }
   32|       |
   33|  15.2k|  size_t uuid_count = data.size() / uuid_size;
   34|  38.7k|  for (size_t i = 0; i < uuid_count; i++) {
  ------------------
  |  Branch (34:22): [True: 23.6k, False: 15.1k]
  ------------------
   35|  23.6k|    const BufferView uuid_bytes(data.data() + (i * uuid_size), uuid_size);
   36|  23.6k|    UUID uuid;
   37|  23.6k|    if (!UUID::FromBytes(uuid_bytes, &uuid) || !func(uuid)) {
  ------------------
  |  Branch (37:9): [True: 0, False: 23.6k]
  |  Branch (37:48): [True: 164, False: 23.4k]
  ------------------
   38|    164|      return false;
   39|    164|    }
   40|  23.6k|  }
   41|       |
   42|  15.1k|  return true;
   43|  15.2k|}
_ZN2bt11SizeForTypeENS_8DataTypeE:
   45|  38.9k|UUIDElemSize SizeForType(DataType type) {
   46|  38.9k|  PW_MODIFY_DIAGNOSTICS_PUSH();
   47|  38.9k|  PW_MODIFY_DIAGNOSTIC(ignored, "-Wswitch-enum");
   48|  38.9k|  switch (type) {
   49|    371|    case DataType::kIncomplete16BitServiceUuids:
  ------------------
  |  Branch (49:5): [True: 371, False: 38.6k]
  ------------------
   50|  1.39k|    case DataType::kComplete16BitServiceUuids:
  ------------------
  |  Branch (50:5): [True: 1.02k, False: 37.9k]
  ------------------
   51|  6.12k|    case DataType::kServiceData16Bit:
  ------------------
  |  Branch (51:5): [True: 4.72k, False: 34.2k]
  ------------------
   52|  6.46k|    case DataType::kSolicitationUuid16Bit:
  ------------------
  |  Branch (52:5): [True: 339, False: 38.6k]
  ------------------
   53|  6.46k|      return UUIDElemSize::k16Bit;
   54|    945|    case DataType::kIncomplete32BitServiceUuids:
  ------------------
  |  Branch (54:5): [True: 945, False: 38.0k]
  ------------------
   55|  10.0k|    case DataType::kComplete32BitServiceUuids:
  ------------------
  |  Branch (55:5): [True: 9.09k, False: 29.8k]
  ------------------
   56|  13.9k|    case DataType::kServiceData32Bit:
  ------------------
  |  Branch (56:5): [True: 3.89k, False: 35.0k]
  ------------------
   57|  14.2k|    case DataType::kSolicitationUuid32Bit:
  ------------------
  |  Branch (57:5): [True: 285, False: 38.6k]
  ------------------
   58|  14.2k|      return UUIDElemSize::k32Bit;
   59|  1.65k|    case DataType::kIncomplete128BitServiceUuids:
  ------------------
  |  Branch (59:5): [True: 1.65k, False: 37.3k]
  ------------------
   60|  2.92k|    case DataType::kComplete128BitServiceUuids:
  ------------------
  |  Branch (60:5): [True: 1.26k, False: 37.7k]
  ------------------
   61|  17.9k|    case DataType::kServiceData128Bit:
  ------------------
  |  Branch (61:5): [True: 15.0k, False: 23.9k]
  ------------------
   62|  18.2k|    case DataType::kSolicitationUuid128Bit:
  ------------------
  |  Branch (62:5): [True: 331, False: 38.6k]
  ------------------
   63|  18.2k|      return UUIDElemSize::k128Bit;
   64|      0|    default:
  ------------------
  |  Branch (64:5): [True: 0, False: 38.9k]
  ------------------
   65|      0|      break;
   66|  38.9k|  };
   67|      0|  PW_MODIFY_DIAGNOSTICS_POP();
   68|       |
   69|      0|  PW_CRASH("called SizeForType with non-UUID DataType %du",
  ------------------
  |  |   30|      0|  do {                                                                       \
  |  |   31|      0|    if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (31:9): [Folded - Ignored]
  |  |  ------------------
  |  |   32|      0|      _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   33|      0|    }                                                                        \
  |  |   34|      0|    PW_HANDLE_CRASH(__VA_ARGS__);                                            \
  |  |  ------------------
  |  |  |  |   23|      0|  PW_ASSERT_PRINT_EXPRESSION("CRASH", "PW_CRASH()"); \
  |  |  |  |   24|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (35:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   70|      0|           static_cast<uint8_t>(type));
   71|      0|  return UUIDElemSize::k16Bit;
   72|      0|}
_ZN2bt20SupplementDataReaderC2ERKNS_10ByteBufferE:
   75|  3.62k|    : is_valid_(true), remaining_(data) {
   76|  3.62k|  if (!remaining_.size()) {
  ------------------
  |  Branch (76:7): [True: 0, False: 3.62k]
  ------------------
   77|      0|    is_valid_ = false;
   78|      0|    return;
   79|      0|  }
   80|       |
   81|       |  // Do a validity check.
   82|  3.62k|  BufferView tmp(remaining_);
   83|   244k|  while (tmp.size()) {
  ------------------
  |  Branch (83:10): [True: 240k, False: 3.44k]
  ------------------
   84|   240k|    size_t tlv_len = tmp[0];
   85|       |
   86|       |    // A struct can have 0 as its length. In that case its valid to terminate.
   87|   240k|    if (!tlv_len)
  ------------------
  |  Branch (87:9): [True: 164, False: 240k]
  ------------------
   88|    164|      break;
   89|       |
   90|       |    // The full struct includes the length octet itself.
   91|   240k|    size_t struct_size = tlv_len + 1;
   92|   240k|    if (struct_size > tmp.size()) {
  ------------------
  |  Branch (92:9): [True: 19, False: 240k]
  ------------------
   93|     19|      is_valid_ = false;
   94|     19|      break;
   95|     19|    }
   96|       |
   97|   240k|    tmp = tmp.view(struct_size);
   98|   240k|  }
   99|  3.62k|}
_ZN2bt20SupplementDataReader12GetNextFieldEPNS_8DataTypeEPNS_10BufferViewE:
  102|   150k|                                        BufferView* out_data) {
  103|   150k|  PW_DCHECK(out_type);
  ------------------
  |  |   51|   150k|  do {                            \
  |  |   52|   150k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |   53|   150k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|   150k|  do {                                                                         \
  |  |  |  |   40|   150k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 150k]
  |  |  |  |  ------------------
  |  |  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |  |  |   45|      0|      }                                                                        \
  |  |  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   47|      0|    }                                                                          \
  |  |  |  |   48|   150k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|   150k|    }                             \
  |  |   55|   150k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  104|   150k|  PW_DCHECK(out_data);
  ------------------
  |  |   51|   150k|  do {                            \
  |  |   52|   150k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |   53|   150k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|   150k|  do {                                                                         \
  |  |  |  |   40|   150k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 150k]
  |  |  |  |  ------------------
  |  |  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |  |  |   45|      0|      }                                                                        \
  |  |  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   47|      0|    }                                                                          \
  |  |  |  |   48|   150k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|   150k|    }                             \
  |  |   55|   150k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  105|       |
  106|   150k|  if (!HasMoreData())
  ------------------
  |  Branch (106:7): [True: 3.30k, False: 147k]
  ------------------
  107|  3.30k|    return false;
  108|       |
  109|   147k|  size_t tlv_len = remaining_[0];
  110|   147k|  size_t cur_struct_size = tlv_len + 1;
  111|   147k|  PW_DCHECK(cur_struct_size <= remaining_.size());
  ------------------
  |  |   51|   147k|  do {                            \
  |  |   52|   147k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |   53|   147k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|   147k|  do {                                                                         \
  |  |  |  |   40|   147k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 147k]
  |  |  |  |  ------------------
  |  |  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |  |  |   45|      0|      }                                                                        \
  |  |  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   47|      0|    }                                                                          \
  |  |  |  |   48|   147k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|   147k|    }                             \
  |  |   55|   147k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  112|       |
  113|   147k|  *out_type = static_cast<DataType>(remaining_[1]);
  114|   147k|  *out_data = remaining_.view(2, tlv_len - 1);
  115|       |
  116|       |  // Update |remaining_|.
  117|   147k|  remaining_ = remaining_.view(cur_struct_size);
  118|   147k|  return true;
  119|   147k|}
_ZNK2bt20SupplementDataReader11HasMoreDataEv:
  121|   150k|bool SupplementDataReader::HasMoreData() const {
  122|   150k|  if (!is_valid_ || !remaining_.size())
  ------------------
  |  Branch (122:7): [True: 0, False: 150k]
  |  Branch (122:21): [True: 3.18k, False: 147k]
  ------------------
  123|  3.18k|    return false;
  124|       |
  125|       |  // If the buffer is valid and has remaining bytes but the length of the next
  126|       |  // segment is zero, then we terminate.
  127|   147k|  return !!remaining_[0];
  128|   150k|}

_ZN2bt4UUID9FromBytesERKNS_10ByteBufferEPS0_:
   25|  47.2k|bool UUID::FromBytes(const ByteBuffer& bytes, UUID* out_uuid) {
   26|  47.2k|  switch (bytes.size()) {
  ------------------
  |  Branch (26:11): [True: 0, False: 47.2k]
  ------------------
   27|  15.7k|    case UUIDElemSize::k16Bit: {
  ------------------
  |  Branch (27:5): [True: 15.7k, False: 31.5k]
  ------------------
   28|  15.7k|      uint16_t dst;
   29|  15.7k|      memcpy(&dst, bytes.data(), sizeof(dst));
   30|  15.7k|      *out_uuid = UUID(pw::bytes::ConvertOrderFrom(cpp20::endian::little, dst));
   31|  15.7k|      return true;
   32|      0|    }
   33|  10.2k|    case UUIDElemSize::k32Bit: {
  ------------------
  |  Branch (33:5): [True: 10.2k, False: 37.0k]
  ------------------
   34|  10.2k|      uint32_t dst;
   35|  10.2k|      memcpy(&dst, bytes.data(), sizeof(dst));
   36|  10.2k|      *out_uuid = UUID(pw::bytes::ConvertOrderFrom(cpp20::endian::little, dst));
   37|  10.2k|      return true;
   38|      0|    }
   39|  21.3k|    case UUIDElemSize::k128Bit: {
  ------------------
  |  Branch (39:5): [True: 21.3k, False: 25.9k]
  ------------------
   40|  21.3k|      UInt128 dst;
   41|  21.3k|      memcpy(dst.data(), bytes.data(), sizeof(dst));
   42|  21.3k|      *out_uuid = UUID(dst);
   43|  21.3k|      return true;
   44|      0|    }
   45|  47.2k|  }
   46|       |
   47|      0|  return false;
   48|  47.2k|}
_ZNK2bt4UUIDeqERKS0_:
   69|  40.9k|bool UUID::operator==(const UUID& uuid) const { return value_ == uuid.value_; }
_ZNK2bt4UUID8ToStringEv:
   99|  10.8k|std::string UUID::ToString() const {
  100|  10.8k|  char out[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")];
  101|  10.8k|  pw::StatusWithSize result = pw::string::Format(
  102|  10.8k|      {out, sizeof(out)},
  103|  10.8k|      "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
  104|  10.8k|      value_[15],
  105|  10.8k|      value_[14],
  106|  10.8k|      value_[13],
  107|  10.8k|      value_[12],
  108|  10.8k|      value_[11],
  109|  10.8k|      value_[10],
  110|  10.8k|      value_[9],
  111|  10.8k|      value_[8],
  112|  10.8k|      value_[7],
  113|  10.8k|      value_[6],
  114|  10.8k|      value_[5],
  115|  10.8k|      value_[4],
  116|  10.8k|      value_[3],
  117|  10.8k|      value_[2],
  118|  10.8k|      value_[1],
  119|  10.8k|      value_[0]);
  120|  10.8k|  PW_DCHECK(result.ok());
  ------------------
  |  |   51|  10.8k|  do {                            \
  |  |   52|  10.8k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|  10.8k|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|  10.8k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  10.8k|  do {                                                                         \
  |  |  |  |   40|  10.8k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 10.8k]
  |  |  |  |  ------------------
  |  |  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |  |  |   45|      0|      }                                                                        \
  |  |  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   47|      0|    }                                                                          \
  |  |  |  |   48|  10.8k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  10.8k|    }                             \
  |  |   55|  10.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  121|  10.8k|  return out;
  122|  10.8k|}
_ZNK2bt4UUID11CompactSizeEb:
  124|  82.4k|UUIDElemSize UUID::CompactSize(bool allow_32bit) const {
  125|  82.4k|  switch (type_) {
  ------------------
  |  Branch (125:11): [True: 0, False: 82.4k]
  ------------------
  126|  35.1k|    case Type::k16Bit:
  ------------------
  |  Branch (126:5): [True: 35.1k, False: 47.3k]
  ------------------
  127|  35.1k|      return UUIDElemSize::k16Bit;
  128|  21.0k|    case Type::k32Bit:
  ------------------
  |  Branch (128:5): [True: 21.0k, False: 61.4k]
  ------------------
  129|  21.0k|      if (allow_32bit)
  ------------------
  |  Branch (129:11): [True: 21.0k, False: 0]
  ------------------
  130|  21.0k|        return UUIDElemSize::k32Bit;
  131|       |
  132|       |      // Fall through if 32-bit UUIDs are not allowed.
  133|      0|      [[fallthrough]];
  134|  26.2k|    case Type::k128Bit:
  ------------------
  |  Branch (134:5): [True: 26.2k, False: 56.2k]
  ------------------
  135|  26.2k|      return UUIDElemSize::k128Bit;
  136|  82.4k|  };
  137|      0|  PW_CRASH("uuid type of %du is invalid", static_cast<uint8_t>(type_));
  ------------------
  |  |   30|      0|  do {                                                                       \
  |  |   31|      0|    if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (31:9): [Folded - Ignored]
  |  |  ------------------
  |  |   32|      0|      _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   33|      0|    }                                                                        \
  |  |   34|      0|    PW_HANDLE_CRASH(__VA_ARGS__);                                            \
  |  |  ------------------
  |  |  |  |   23|      0|  PW_ASSERT_PRINT_EXPRESSION("CRASH", "PW_CRASH()"); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|  fflush(stdout);                                                \
  |  |  |  |  |  |   60|      0|  fprintf(stderr, "\033[31m" _PW_ASSERT_CRASH_BANNER "\033[0m"); \
  |  |  |  |  |  |   61|      0|  fprintf(stderr,                                     \
  |  |  |  |  |  |   62|      0|          "\033[41m\033[37m\033[1m%s:%d:\033[0m "     \
  |  |  |  |  |  |   63|      0|          "\033[1m"                                   \
  |  |  |  |  |  |   64|      0|          _PW_ASSERT_MACRO(macro)                     \
  |  |  |  |  |  |   65|      0|          " "                                         \
  |  |  |  |  |  |   66|      0|          "\033[31mFAILED!\033[0m\n\n"                \
  |  |  |  |  |  |   67|      0|          "  \033[33mFAILED ASSERTION\033[0m\n\n"                    \
  |  |  |  |  |  |   68|      0|          "    %s\n\n"                                \
  |  |  |  |  |  |   69|      0|          "  \033[33mFILE & LINE\033[0m\n\n"                         \
  |  |  |  |  |  |   70|      0|          "    %s:%d\n\n"                             \
  |  |  |  |  |  |   71|      0|          "  \033[33mFUNCTION\033[0m\n\n"                            \
  |  |  |  |  |  |   72|      0|          "    %s\n\n",                               \
  |  |  |  |  |  |   73|      0|          __FILE__,                                   \
  |  |  |  |  |  |   74|      0|          __LINE__,                                   \
  |  |  |  |  |  |   75|      0|          expression,                                 \
  |  |  |  |  |  |   76|      0|          __FILE__,                                   \
  |  |  |  |  |  |   77|      0|          __LINE__,                                   \
  |  |  |  |  |  |   78|      0|          _PW_ASSERT_ABORT_FUNCTION)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   28|      0|#define _PW_ASSERT_ABORT_FUNCTION __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   24|      0|  _PW_ASSERT_PRINT_MESSAGE_AND_ABORT(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|  fprintf(stderr, "  \033[33mMESSAGE\033[0m\n\n    " __VA_ARGS__); \
  |  |  |  |  |  |   50|      0|  fprintf(stderr, "\n\n");                                         \
  |  |  |  |  |  |   51|      0|  fflush(stderr);                                                  \
  |  |  |  |  |  |   52|      0|  abort()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (35:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  138|      0|}
_ZNK2bt4UUID7ToBytesEPNS_17MutableByteBufferEb:
  140|  10.7k|size_t UUID::ToBytes(MutableByteBuffer* bytes, bool allow_32bit) const {
  141|  10.7k|  size_t size = CompactSize(allow_32bit);
  142|  10.7k|  size_t offset = (size == UUIDElemSize::k128Bit) ? 0u : kBaseOffset;
  ------------------
  |  Branch (142:19): [True: 1.36k, False: 9.34k]
  ------------------
  143|  10.7k|  bytes->Write(value_.data() + offset, size);
  144|  10.7k|  return size;
  145|  10.7k|}
_ZNK2bt4UUID4HashEv:
  153|  47.2k|std::size_t UUID::Hash() const {
  154|  47.2k|  static_assert(sizeof(value_) % sizeof(size_t) == 0);
  155|       |  // Morally we'd like to assert this, but:
  156|       |  //
  157|       |  // 'alignof' applied to an expression is a GNU extension.
  158|       |  //
  159|       |  // static_assert(alignof(value_) % alignof(size_t) == 0);
  160|  47.2k|  size_t hash = 0;
  161|   141k|  for (size_t i = 0; i < (sizeof(value_) / sizeof(size_t)); i++) {
  ------------------
  |  Branch (161:22): [True: 94.5k, False: 47.2k]
  ------------------
  162|  94.5k|    hash ^=
  163|  94.5k|        *reinterpret_cast<const size_t*>(value_.data() + (i * sizeof(size_t)));
  164|  94.5k|  }
  165|  47.2k|  return hash;
  166|  47.2k|}

pw_Log:
  101|  43.1k|                       ...) {
  102|  43.1k|  va_list args;
  103|  43.1k|  va_start(args, message);
  104|  43.1k|  pw_Log_HandleMessageVaList(level,
  105|  43.1k|                             flags,
  106|  43.1k|                             module_name,
  107|  43.1k|                             file_name,
  108|  43.1k|                             line_number,
  109|  43.1k|                             function_name,
  110|  43.1k|                             message,
  111|  43.1k|                             args);
  112|  43.1k|  va_end(args);
  113|  43.1k|}
pw_Log_HandleMessageVaList:
  122|  43.1k|                                           va_list args) {
  123|       |  // Accumulate the log message in this buffer, then output it.
  124|  43.1k|  pw::StringBuffer<PW_LOG_BASIC_ENTRY_SIZE> buffer;
  125|       |
  126|       |  // Column: Timestamp
  127|       |  // Note that this macro method defaults to a no-op.
  128|  43.1k|  PW_LOG_APPEND_TIMESTAMP(buffer);
  ------------------
  |  |   67|  43.1k|  do {                                  \
  |  |   68|  43.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (68:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  129|       |
  130|       |  // Column: Filename
  131|       |#if PW_LOG_SHOW_FILENAME
  132|       |  buffer.Format(" %-30s:%4d |", GetFileBasename(file_name), line_number);
  133|       |#else
  134|  43.1k|  static_cast<void>(file_name);
  135|  43.1k|  static_cast<void>(line_number);
  136|  43.1k|#endif
  137|       |
  138|       |  // Column: Function
  139|       |#if PW_LOG_SHOW_FUNCTION
  140|       |  buffer.Format(" %-30s |", function_name);
  141|       |#else
  142|  43.1k|  static_cast<void>(function_name);
  143|  43.1k|#endif
  144|       |
  145|       |  // Column: Module
  146|       |#if PW_LOG_SHOW_MODULE
  147|       |  buffer << " " BOLD;
  148|       |  buffer.Format("%3s", module_name);
  149|       |  buffer << RESET " ";
  150|       |#else
  151|  43.1k|  static_cast<void>(module_name);
  152|  43.1k|#endif  // PW_LOG_SHOW_MODULE
  153|       |
  154|       |  // Column: Flag
  155|       |#if PW_LOG_SHOW_FLAG
  156|       |#if PW_EMOJI
  157|       |  buffer << (flags ? "🚩" : "  ");
  158|       |#else
  159|       |  buffer << (flags ? "*" : "|");
  160|       |#endif  // PW_EMOJI
  161|       |  buffer << " ";
  162|       |#else
  163|  43.1k|  static_cast<void>(flags);
  164|  43.1k|#endif  // PW_LOG_SHOW_FLAG
  165|       |
  166|       |  // Column: Level
  167|  43.1k|  buffer << LogLevelToLogLevelName(level) << "  ";
  168|       |
  169|       |  // Column: Message
  170|  43.1k|  buffer.FormatVaList(message, args);
  171|       |
  172|       |  // All done; flush the log.
  173|  43.1k|  write_log(buffer);
  174|  43.1k|}
log_basic.cc:_ZN2pw9log_basic12_GLOBAL__N_122LogLevelToLogLevelNameEi:
   44|  43.1k|const char* LogLevelToLogLevelName(int level) {
   45|  43.1k|  switch (level) {
   46|       |    // clang-format off
   47|       |#if PW_EMOJI
   48|       |    case PW_LOG_LEVEL_DEBUG    : return "👾" RESET;
   49|       |    case PW_LOG_LEVEL_INFO     : return "ℹ️ " RESET;
   50|       |    case PW_LOG_LEVEL_WARN     : return "⚠️ " RESET;
   51|       |    case PW_LOG_LEVEL_ERROR    : return "❌" RESET;
   52|       |    case PW_LOG_LEVEL_CRITICAL : return "☠️ " RESET;
   53|       |    default: return "❔" RESET;
   54|       |#else
   55|  14.2k|    case PW_LOG_LEVEL_DEBUG    : return BLUE     BOLD        "DBG" RESET;
  ------------------
  |  |   21|  14.2k|#define PW_LOG_LEVEL_DEBUG    1
  ------------------
                  case PW_LOG_LEVEL_DEBUG    : return BLUE     BOLD        "DBG" RESET;
  ------------------
  |  |   32|  14.2k|#define BLUE      "\033[96m"
  ------------------
                  case PW_LOG_LEVEL_DEBUG    : return BLUE     BOLD        "DBG" RESET;
  ------------------
  |  |   38|  14.2k|#define RESET     "\033[0m"
  ------------------
  |  Branch (55:5): [True: 14.2k, False: 28.9k]
  ------------------
   56|  18.8k|    case PW_LOG_LEVEL_INFO     : return MAGENTA  BOLD        "INF" RESET;
  ------------------
  |  |   22|  18.8k|#define PW_LOG_LEVEL_INFO     2
  ------------------
                  case PW_LOG_LEVEL_INFO     : return MAGENTA  BOLD        "INF" RESET;
  ------------------
  |  |   28|  18.8k|#define MAGENTA   "\033[35m"
  ------------------
                  case PW_LOG_LEVEL_INFO     : return MAGENTA  BOLD        "INF" RESET;
  ------------------
  |  |   38|  18.8k|#define RESET     "\033[0m"
  ------------------
  |  Branch (56:5): [True: 18.8k, False: 24.2k]
  ------------------
   57|  9.30k|    case PW_LOG_LEVEL_WARN     : return YELLOW   BOLD        "WRN" RESET;
  ------------------
  |  |   23|  9.30k|#define PW_LOG_LEVEL_WARN     3
  ------------------
                  case PW_LOG_LEVEL_WARN     : return YELLOW   BOLD        "WRN" RESET;
  ------------------
  |  |   29|  9.30k|#define YELLOW    "\033[33m"
  ------------------
                  case PW_LOG_LEVEL_WARN     : return YELLOW   BOLD        "WRN" RESET;
  ------------------
  |  |   38|  9.30k|#define RESET     "\033[0m"
  ------------------
  |  Branch (57:5): [True: 9.30k, False: 33.8k]
  ------------------
   58|    754|    case PW_LOG_LEVEL_ERROR    : return RED      BOLD        "ERR" RESET;
  ------------------
  |  |   24|    754|#define PW_LOG_LEVEL_ERROR    4
  ------------------
                  case PW_LOG_LEVEL_ERROR    : return RED      BOLD        "ERR" RESET;
  ------------------
  |  |   30|    754|#define RED       "\033[31m"
  ------------------
                  case PW_LOG_LEVEL_ERROR    : return RED      BOLD        "ERR" RESET;
  ------------------
  |  |   38|    754|#define RESET     "\033[0m"
  ------------------
  |  Branch (58:5): [True: 754, False: 42.3k]
  ------------------
   59|      0|    case PW_LOG_LEVEL_CRITICAL : return BLACK    BOLD RED_BG "FTL" RESET;
  ------------------
  |  |   25|      0|#define PW_LOG_LEVEL_CRITICAL 5
  ------------------
                  case PW_LOG_LEVEL_CRITICAL : return BLACK    BOLD RED_BG "FTL" RESET;
  ------------------
  |  |   33|      0|#define BLACK     "\033[30m"
  ------------------
                  case PW_LOG_LEVEL_CRITICAL : return BLACK    BOLD RED_BG "FTL" RESET;
  ------------------
  |  |   38|      0|#define RESET     "\033[0m"
  ------------------
  |  Branch (59:5): [True: 0, False: 43.1k]
  ------------------
   60|      0|    default                    : return GREEN    BOLD        "UNK" RESET;
  ------------------
  |  |   31|      0|#define GREEN     "\033[32m"
  ------------------
                  default                    : return GREEN    BOLD        "UNK" RESET;
  ------------------
  |  |   38|      0|#define RESET     "\033[0m"
  ------------------
  |  Branch (60:5): [True: 0, False: 43.1k]
  ------------------
   61|  43.1k|#endif
   62|       |      // clang-format on
   63|  43.1k|  }
   64|  43.1k|}
log_basic.cc:_ZNK2pw9log_basic12_GLOBAL__N_13$_0clENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   86|  43.1k|void (*write_log)(std::string_view) = [](std::string_view log) {
   87|  43.1k|  sys_io::WriteLine(log)
   88|  43.1k|      .IgnoreError();  // TODO: b/242598609 - Handle Status properly
   89|  43.1k|};

_ZN2pw6string6FormatENS_4spanIcLm18446744073709551615EEEPKcz:
   21|  10.8k|StatusWithSize Format(span<char> buffer, const char* format, ...) {
   22|  10.8k|  va_list args;
   23|  10.8k|  va_start(args, format);
   24|  10.8k|  const StatusWithSize result = FormatVaList(buffer, format, args);
   25|  10.8k|  va_end(args);
   26|       |
   27|  10.8k|  return result;
   28|  10.8k|}
_ZN2pw6string12FormatVaListENS_4spanIcLm18446744073709551615EEEPKcP13__va_list_tag:
   32|  54.0k|                            va_list args) {
   33|  54.0k|  if (buffer.empty()) {
  ------------------
  |  Branch (33:7): [True: 0, False: 54.0k]
  ------------------
   34|      0|    return StatusWithSize::ResourceExhausted();
   35|      0|  }
   36|       |
   37|  54.0k|  const int result = std::vsnprintf(buffer.data(), buffer.size(), format, args);
   38|       |
   39|       |  // If an error occurred, the number of characters written is unknown.
   40|       |  // Discard any output by terminating the buffer.
   41|  54.0k|  if (result < 0) {
  ------------------
  |  Branch (41:7): [True: 0, False: 54.0k]
  ------------------
   42|      0|    buffer[0] = '\0';
   43|      0|    return StatusWithSize::InvalidArgument();
   44|      0|  }
   45|       |
   46|       |  // If result >= buffer.size(), the output was truncated and null-terminated.
   47|  54.0k|  if (static_cast<unsigned>(result) >= buffer.size()) {
  ------------------
  |  Branch (47:7): [True: 754, False: 53.2k]
  ------------------
   48|    754|    return StatusWithSize::ResourceExhausted(buffer.size() - 1);
   49|    754|  }
   50|       |
   51|  53.2k|  return StatusWithSize(result);
   52|  54.0k|}

_ZN2pw13StringBuilder6appendEPKcm:
   37|  86.2k|StringBuilder& StringBuilder::append(const char* str, size_t count) {
   38|  86.2k|  char* const append_destination = buffer_.data() + size();
   39|  86.2k|  std::copy_n(str, ResizeAndTerminate(count), append_destination);
   40|  86.2k|  return *this;
   41|  86.2k|}
_ZN2pw13StringBuilder6appendEPKc:
   43|  86.2k|StringBuilder& StringBuilder::append(const char* str) {
   44|       |  // Use buffer_.size() - size() as the maximum length so that strings too long
   45|       |  // to fit in the buffer will request one character too many, which sets the
   46|       |  // status to RESOURCE_EXHAUSTED.
   47|  86.2k|  return append(string::ClampedCString(str, buffer_.size() - size()));
   48|  86.2k|}
_ZN2pw13StringBuilder6appendENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   50|  86.2k|StringBuilder& StringBuilder::append(std::string_view str) {
   51|  86.2k|  return append(str.data(), str.size());
   52|  86.2k|}
_ZN2pw13StringBuilder18ResizeAndTerminateEm:
   65|  86.2k|size_t StringBuilder::ResizeAndTerminate(size_t chars_to_append) {
   66|  86.2k|  const size_t copied = std::min(chars_to_append, max_size() - size());
   67|       |  // NOTE: `+=` is not used in order to avoid implicit integer conversion which
   68|       |  // results in an error on some compilers.
   69|  86.2k|  *size_ = static_cast<InlineString<>::size_type>(copied + *size_);
   70|  86.2k|  NullTerminate();
   71|       |
   72|  86.2k|  if (buffer_.empty() || chars_to_append != copied) {
  ------------------
  |  Branch (72:7): [True: 0, False: 86.2k]
  |  Branch (72:26): [True: 0, False: 86.2k]
  ------------------
   73|      0|    SetErrorStatus(Status::ResourceExhausted());
   74|  86.2k|  } else {
   75|  86.2k|    last_status_ = StatusCode(OkStatus());
   76|  86.2k|  }
   77|  86.2k|  return copied;
   78|  86.2k|}
_ZN2pw13StringBuilder12FormatVaListEPKcP13__va_list_tag:
   99|  43.1k|StringBuilder& StringBuilder::FormatVaList(const char* format, va_list args) {
  100|  43.1k|  HandleStatusWithSize(
  101|  43.1k|      string::FormatVaList(buffer_.subspan(size()), format, args));
  102|  43.1k|  return *this;
  103|  43.1k|}
_ZN2pw13StringBuilder20HandleStatusWithSizeENS_14StatusWithSizeE:
  121|  43.1k|void StringBuilder::HandleStatusWithSize(StatusWithSize written) {
  122|  43.1k|  const Status status = written.status();
  123|  43.1k|  last_status_ = StatusCode(status);
  124|  43.1k|  if (!status.ok()) {
  ------------------
  |  Branch (124:7): [True: 754, False: 42.3k]
  ------------------
  125|    754|    status_ = StatusCode(status);
  126|    754|  }
  127|       |
  128|       |  // NOTE: `+=` is not used in order to avoid implicit integer conversion which
  129|       |  // results in an error on some compilers.
  130|  43.1k|  *size_ = static_cast<InlineString<>::size_type>(written.size() + *size_);
  131|  43.1k|}

_ZN2pw6sys_io10WriteBytesENS_4spanIKSt4byteLm18446744073709551615EEE:
   29|  43.1k|StatusWithSize WriteBytes(ConstByteSpan src) {
   30|  3.10M|  for (size_t i = 0; i < src.size_bytes(); ++i) {
  ------------------
  |  Branch (30:22): [True: 3.05M, False: 43.1k]
  ------------------
   31|  3.05M|    Status result = WriteByte(src[i]);
   32|  3.05M|    if (!result.ok()) {
  ------------------
  |  Branch (32:9): [True: 0, False: 3.05M]
  ------------------
   33|      0|      return StatusWithSize(result, i);
   34|      0|    }
   35|  3.05M|  }
   36|  43.1k|  return StatusWithSize(src.size_bytes());
   37|  43.1k|}

_ZN2pw6sys_io9WriteByteESt4byte:
   39|  3.10M|Status WriteByte(std::byte b) {
   40|  3.10M|  if (std::putchar(static_cast<char>(b)) == EOF) {
  ------------------
  |  Branch (40:7): [True: 0, False: 3.10M]
  ------------------
   41|      0|    return Status::Internal();
   42|      0|  }
   43|  3.10M|  return OkStatus();
   44|  3.10M|}
_ZN2pw6sys_io9WriteLineENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   46|  43.1k|StatusWithSize WriteLine(std::string_view s) {
   47|  43.1k|  size_t chars_written = 0;
   48|  43.1k|  StatusWithSize size_result = WriteBytes(as_bytes(span(s)));
   49|  43.1k|  if (!size_result.ok()) {
  ------------------
  |  Branch (49:7): [True: 0, False: 43.1k]
  ------------------
   50|      0|    return size_result;
   51|      0|  }
   52|  43.1k|  chars_written += size_result.size();
   53|       |
   54|       |  // Write trailing newline character.
   55|  43.1k|  Status result = WriteByte(static_cast<std::byte>('\n'));
   56|  43.1k|  if (result.ok()) {
  ------------------
  |  Branch (56:7): [True: 43.1k, False: 0]
  ------------------
   57|  43.1k|    chars_written++;
   58|  43.1k|  }
   59|       |
   60|  43.1k|  return StatusWithSize(result, chars_written);
   61|  43.1k|}