_ZN2bt10ByteBufferD2Ev:
   48|  68.8k|  virtual ~ByteBuffer() = default;
_ZNK2bt16StaticByteBufferILm4EE4sizeEv:
  443|  23.5k|  size_t size() const override { return buffer_.size(); }
_ZN2bt16StaticByteBufferILm4EEC2Ev:
  395|  3.92k|  StaticByteBuffer() {
  396|  3.92k|    static_assert(BufferSize, "|BufferSize| must be non-zero");
  397|  3.92k|  }
_ZNK2bt16StaticByteBufferILm4EE4dataEv:
  442|  3.92k|  const uint8_t* data() const override { return buffer_.data(); }
_ZN2bt16StaticByteBufferILm4EE12mutable_dataEv:
  448|  3.92k|  uint8_t* mutable_data() override { return buffer_.data(); }
_ZN2bt17MutableByteBuffer8WriteObjINS_5l2cap11BasicHeaderEEEvRKT_m:
  351|  3.92k|  void WriteObj(const T& data, size_t pos = 0) {
  352|       |    // ByteBuffers are (mostly?) not TriviallyCopyable, but check this first for
  353|       |    // the error to be useful.
  354|  3.92k|    static_assert(!std::is_base_of_v<ByteBuffer, T>,
  355|  3.92k|                  "ByteBuffer passed to WriteObj; use Write");
  356|  3.92k|    static_assert(!std::is_pointer_v<T>,
  357|  3.92k|                  "Pointer passed to WriteObj, deref or use Write");
  358|  3.92k|    static_assert(std::is_trivially_copyable_v<T>,
  359|  3.92k|                  "Unsafe to peek byte representation");
  360|  3.92k|    Write(reinterpret_cast<const uint8_t*>(&data), sizeof(T), pos);
  361|  3.92k|  }
_ZN2bt16StaticByteBufferILm68EEC2Ev:
  395|    114|  StaticByteBuffer() {
  396|    114|    static_assert(BufferSize, "|BufferSize| must be non-zero");
  397|    114|  }
_ZNK2bt16StaticByteBufferILm68EE4dataEv:
  442|    393|  const uint8_t* data() const override { return buffer_.data(); }
_ZNK2bt16StaticByteBufferILm68EE4sizeEv:
  443|  1.58k|  size_t size() const override { return buffer_.size(); }
_ZN2bt16StaticByteBufferILm68EE12mutable_dataEv:
  448|    342|  uint8_t* mutable_data() override { return buffer_.data(); }
_ZN2bt16StaticByteBufferILm260EEC2Ev:
  395|     31|  StaticByteBuffer() {
  396|     31|    static_assert(BufferSize, "|BufferSize| must be non-zero");
  397|     31|  }
_ZNK2bt16StaticByteBufferILm260EE4dataEv:
  442|    202|  const uint8_t* data() const override { return buffer_.data(); }
_ZNK2bt16StaticByteBufferILm260EE4sizeEv:
  443|    621|  size_t size() const override { return buffer_.size(); }
_ZN2bt16StaticByteBufferILm260EE12mutable_dataEv:
  448|     93|  uint8_t* mutable_data() override { return buffer_.data(); }
_ZN2bt16StaticByteBufferILm1028EEC2Ev:
  395|  3.78k|  StaticByteBuffer() {
  396|  3.78k|    static_assert(BufferSize, "|BufferSize| must be non-zero");
  397|  3.78k|  }
_ZNK2bt16StaticByteBufferILm1028EE4dataEv:
  442|  12.1k|  const uint8_t* data() const override { return buffer_.data(); }
_ZNK2bt16StaticByteBufferILm1028EE4sizeEv:
  443|  50.7k|  size_t size() const override { return buffer_.size(); }
_ZN2bt16StaticByteBufferILm1028EE12mutable_dataEv:
  448|  11.3k|  uint8_t* mutable_data() override { return buffer_.data(); }
_ZNK2bt10ByteBuffer2ToINS_8hci_spec13ACLDataHeaderEEEDav:
  129|  8.08k|  [[nodiscard]] auto To() const {
  130|  8.08k|    static_assert(std::is_trivially_copyable_v<T>,
  131|  8.08k|                  "unsafe to copy representation");
  132|  8.08k|    static_assert(std::is_default_constructible_v<T>);
  133|  8.08k|    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|  8.08k|    OutType out{};
  141|  8.08k|    CopyRaw(/*dst_data=*/std::addressof(out),
  142|  8.08k|            /*dst_capacity=*/sizeof(out),
  143|  8.08k|            /*src_offset=*/0,
  144|  8.08k|            /*copy_size=*/sizeof(out));
  145|  8.08k|    return out;
  146|  8.08k|  }
_ZN2bt17DynamicByteBufferD2Ev:
  472|    229|  ~DynamicByteBuffer() override = default;

_ZNK2bt14PacketViewBase12payload_dataEv:
   34|  4.61k|  BufferView payload_data() const {
   35|  4.61k|    return buffer_->view(header_size(), size_ - header_size());
   36|  4.61k|  }
_ZNK2bt14PacketViewBase4sizeEv:
   38|  21.0k|  size_t size() const { return size_; }
_ZNK2bt14PacketViewBase12payload_sizeEv:
   39|  4.61k|  size_t payload_size() const {
   40|  4.61k|    PW_CHECK(size() >= header_size());
  ------------------
  |  |   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); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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|  4.61k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   41|  4.61k|    return size() - header_size();
   42|  4.61k|  }
_ZN2bt14PacketViewBaseC2EmPKNS_10ByteBufferEm:
   67|  3.92k|      : header_size_(header_size),
   68|  3.92k|        buffer_(buffer),
   69|  3.92k|        size_(header_size_ + payload_size) {
   70|  3.92k|    PW_CHECK(buffer_);
  ------------------
  |  |   39|  3.92k|  do {                                                                         \
  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  ------------------
  |  |   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.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   71|  3.92k|    PW_CHECK(buffer_->size() >= size_,
  ------------------
  |  |   39|  3.92k|  do {                                                                         \
  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  ------------------
  |  |   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.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   72|  3.92k|             "view size %zu exceeds buffer size %zu",
   73|  3.92k|             size_,
   74|  3.92k|             buffer_->size());
   75|  3.92k|  }
_ZNK2bt14PacketViewBase11header_sizeEv:
   88|  26.3k|  size_t header_size() const { return header_size_; }
_ZNK2bt14PacketViewBase6bufferEv:
   90|  19.8k|  const ByteBuffer* buffer() const { return buffer_; }
_ZNK2bt14PacketViewBase12mutable_dataEv:
   93|  7.85k|  MutableBufferView mutable_data() const {
   94|  7.85k|    return mutable_buffer()->mutable_view(0, this->size());
   95|  7.85k|  }
_ZNK2bt14PacketViewBase20mutable_payload_dataEv:
   98|  3.92k|  MutableBufferView mutable_payload_data() const {
   99|  3.92k|    return mutable_buffer()->mutable_view(header_size(),
  100|  3.92k|                                          this->size() - header_size());
  101|  3.92k|  }
_ZNK2bt14PacketViewBase14mutable_bufferEv:
  111|  11.7k|  MutableByteBuffer* mutable_buffer() const {
  112|       |    // For use only by MutableBufferView, which is constructed with a
  113|       |    // MutableBufferView*. This restores the mutability that is implicitly
  114|       |    // upcasted away when stored in this Base class.
  115|  11.7k|    return const_cast<MutableByteBuffer*>(
  116|  11.7k|        static_cast<const MutableByteBuffer*>(this->buffer()));
  117|  11.7k|  }
_ZNK2bt14PacketViewBase7payloadINS_5l2cap11BasicHeaderEEERKT_v:
   45|    687|  const PayloadType& payload() const {
   46|    687|    PW_CHECK(sizeof(PayloadType) <= payload_size());
  ------------------
  |  |   39|    687|  do {                                                                         \
  |  |   40|    687|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 687]
  |  |  ------------------
  |  |   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|    687|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   47|    687|    return *reinterpret_cast<const PayloadType*>(payload_data().data());
   48|    687|  }
_ZN2bt17MutablePacketViewINS_8hci_spec13ACLDataHeaderEEC2EPNS_17MutableByteBufferEm:
  184|  3.92k|      : PacketView<HeaderType>(buffer, payload_size) {}
_ZN2bt10PacketViewINS_8hci_spec13ACLDataHeaderEEC2EPKNS_10ByteBufferEm:
  174|  3.92k|      : PacketViewBase(sizeof(HeaderType), buffer, payload_size) {}
_ZNK2bt10PacketViewINS_8hci_spec13ACLDataHeaderEE6headerEv:
  176|  8.08k|  HeaderType header() const { return buffer()->template To<HeaderType>(); }
_ZNK2bt17MutablePacketViewINS_8hci_spec13ACLDataHeaderEE14mutable_headerEv:
  190|  7.85k|  HeaderType* mutable_header() const {
  191|  7.85k|    return reinterpret_cast<HeaderType*>(mutable_data().mutable_data());
  192|  7.85k|  }

_ZN2bt5l2cap8internal17BasicModeRxEngineC2Ev:
   24|    229|  BasicModeRxEngine() = default;

_ZNK2bt5l2cap13OutboundFrame11include_fcsEv:
   51|  16.1k|  bool include_fcs() const {
   52|  16.1k|    return fcs_option_ == FrameCheckSequenceOption::kIncludeFcs;
   53|  16.1k|  }

_ZN2bt5l2cap3PDUD2Ev:
   43|    458|  ~PDU() = default;
_ZNK2bt5l2cap3PDU8is_validEv:
   51|  4.61k|  bool is_valid() const { return !fragments_.empty(); }
_ZNK2bt5l2cap3PDU6lengthEv:
   58|    687|  uint16_t length() const {
   59|    687|    return pw::bytes::ConvertOrderFrom(cpp20::endian::little,
   60|    687|                                       basic_header().length);
   61|    687|  }
_ZN2bt5l2cap3PDUC2Ev:
   42|    229|  PDU() = default;

_ZN2bt5l2cap8internal8RxEngineC2Ev:
   27|    229|  RxEngine() = default;
_ZN2bt5l2cap8internal8RxEngineD2Ev:
   28|    229|  virtual ~RxEngine() = default;

_ZN2bt3hci10PacketBaseINS_8hci_spec13ACLDataHeaderENS0_6PacketIS3_EEE12mutable_viewEv:
  103|  11.7k|  MutablePacketView<HeaderType>* mutable_view() { return &view_; }
_ZNK2bt3hci10PacketBaseINS_8hci_spec13ACLDataHeaderENS0_6PacketIS3_EEE4viewEv:
  102|  16.6k|  const PacketView<HeaderType>& view() const { return view_; }
_ZN2bt3hci10PacketBaseINS_8hci_spec13ACLDataHeaderENS0_6PacketIS3_EEEC2ERKNS_17MutablePacketViewIS3_EE:
  107|  3.92k|      : view_(view) {}
_ZN2bt3hci10PacketBaseINS_8hci_spec13ACLDataHeaderENS0_6PacketIS3_EEED2Ev:
  100|  3.92k|  virtual ~PacketBase() = default;

_ZN2bt3hci10allocators8internal15FixedSizePacketINS_8hci_spec13ACLDataHeaderELm68EEC2Em:
   93|    114|      : Packet<HeaderType>(
   94|    114|            MutablePacketView<HeaderType>(&this->buffer_, payload_size)) {}
_ZN2bt3hci10allocators8internal15FixedSizePacketINS_8hci_spec13ACLDataHeaderELm68EED2Ev:
   96|    114|  ~FixedSizePacket() override = default;
_ZN2bt3hci10allocators8internal15FixedSizePacketINS_8hci_spec13ACLDataHeaderELm260EEC2Em:
   93|     31|      : Packet<HeaderType>(
   94|     31|            MutablePacketView<HeaderType>(&this->buffer_, payload_size)) {}
_ZN2bt3hci10allocators8internal15FixedSizePacketINS_8hci_spec13ACLDataHeaderELm260EED2Ev:
   96|     31|  ~FixedSizePacket() override = default;
_ZN2bt3hci10allocators8internal15FixedSizePacketINS_8hci_spec13ACLDataHeaderELm1028EEC2Em:
   93|  3.78k|      : Packet<HeaderType>(
   94|  3.78k|            MutablePacketView<HeaderType>(&this->buffer_, payload_size)) {}
_ZN2bt3hci10allocators8internal15FixedSizePacketINS_8hci_spec13ACLDataHeaderELm1028EED2Ev:
   96|  3.78k|  ~FixedSizePacket() override = default;

_ZN2pw5bytes12ConvertOrderItEET_N5cpp206endianES4_S2_:
  119|  20.5k|constexpr T ConvertOrder(endian from, endian to, T value) {
  120|  20.5k|  return from == to ? value : internal::ReverseBytes(value);
  ------------------
  |  Branch (120:10): [True: 20.5k, False: 0]
  ------------------
  121|  20.5k|}
_ZN2pw5bytes16ConvertOrderFromItEET_N5cpp206endianES2_:
  133|  8.77k|constexpr T ConvertOrderFrom(endian from_endianness, T value) {
  134|  8.77k|  return ConvertOrder(from_endianness, endian::native, value);
  135|  8.77k|}
_ZN2pw5bytes14ConvertOrderToItEET_N5cpp206endianES2_:
  127|  11.7k|constexpr T ConvertOrderTo(endian to_endianness, T value) {
  128|  11.7k|  return ConvertOrder(endian::native, to_endianness, value);
  129|  11.7k|}
_ZN2pw5bytes14ConvertOrderToImEET_N5cpp206endianES2_:
  127|  3.92k|constexpr T ConvertOrderTo(endian to_endianness, T value) {
  128|  3.92k|  return ConvertOrder(endian::native, to_endianness, value);
  129|  3.92k|}
_ZN2pw5bytes12ConvertOrderImEET_N5cpp206endianES4_S2_:
  119|  3.92k|constexpr T ConvertOrder(endian from, endian to, T value) {
  120|  3.92k|  return from == to ? value : internal::ReverseBytes(value);
  ------------------
  |  Branch (120:10): [True: 3.92k, False: 0]
  ------------------
  121|  3.92k|}

_ZNK2bt10ByteBuffer4CopyEPNS_17MutableByteBufferE:
   25|  7.85k|void ByteBuffer::Copy(MutableByteBuffer* out_buffer) const {
   26|  7.85k|  PW_CHECK(out_buffer);
  ------------------
  |  |   39|  7.85k|  do {                                                                         \
  |  |   40|  7.85k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 7.85k]
  |  |  ------------------
  |  |   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|  7.85k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   27|  7.85k|  CopyRaw(out_buffer->mutable_data(), out_buffer->size(), 0, size());
   28|  7.85k|}
_ZNK2bt10ByteBuffer4CopyEPNS_17MutableByteBufferEmm:
   32|  4.15k|                      size_t size) const {
   33|  4.15k|  PW_CHECK(out_buffer);
  ------------------
  |  |   39|  4.15k|  do {                                                                         \
  |  |   40|  4.15k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 4.15k]
  |  |  ------------------
  |  |   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|  4.15k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   34|  4.15k|  CopyRaw(out_buffer->mutable_data(), out_buffer->size(), pos, size);
   35|  4.15k|}
_ZNK2bt10ByteBuffer4viewEmm:
   60|  17.0k|BufferView ByteBuffer::view(size_t pos, size_t size) const {
   61|  17.0k|  PW_CHECK(pos <= this->size(),
  ------------------
  |  |   39|  17.0k|  do {                                                                         \
  |  |   40|  17.0k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 17.0k]
  |  |  ------------------
  |  |   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|  17.0k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   62|  17.0k|           "offset past buffer (pos: %zu, size: %zu)",
   63|  17.0k|           pos,
   64|  17.0k|           this->size());
   65|  17.0k|  return BufferView(data() + pos, std::min(size, this->size() - pos));
   66|  17.0k|}
_ZNK2bt10ByteBuffer7CopyRawEPvmmm:
  110|  20.1k|                         size_t copy_size) const {
  111|  20.1k|  PW_CHECK(copy_size == 0 || dst_data != nullptr,
  ------------------
  |  |   39|  20.1k|  do {                                                                         \
  |  |   40|  40.2k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:11): [True: 0, False: 20.1k]
  |  |  |  Branch (40:11): [True: 20.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|  20.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  112|  20.1k|           "%zu byte write to pointer %p",
  113|  20.1k|           copy_size,
  114|  20.1k|           dst_data);
  115|  20.1k|  PW_CHECK(copy_size <= dst_capacity,
  ------------------
  |  |   39|  20.1k|  do {                                                                         \
  |  |   40|  20.1k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 20.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|  20.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|  20.1k|           "destination not large enough (required: %zu, available: %zu)",
  117|  20.1k|           copy_size,
  118|  20.1k|           dst_capacity);
  119|  20.1k|  PW_CHECK(src_offset <= this->size(),
  ------------------
  |  |   39|  20.1k|  do {                                                                         \
  |  |   40|  20.1k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 20.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|  20.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  120|  20.1k|           "offset exceeds source range (begin: %zu, copy_size: %zu)",
  121|  20.1k|           src_offset,
  122|  20.1k|           this->size());
  123|  20.1k|  PW_CHECK(
  ------------------
  |  |   39|  20.1k|  do {                                                                         \
  |  |   40|  20.1k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 20.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|  20.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  124|  20.1k|      std::numeric_limits<size_t>::max() - copy_size >= src_offset,
  125|  20.1k|      "end of source range overflows size_t (src_offset: %zu, copy_size: %zu)",
  126|  20.1k|      src_offset,
  127|  20.1k|      copy_size);
  128|  20.1k|  PW_CHECK(src_offset + copy_size <= this->size(),
  ------------------
  |  |   39|  20.1k|  do {                                                                         \
  |  |   40|  20.1k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 20.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|  20.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  129|  20.1k|           "end exceeds source range (end: %zu, copy_size: %zu)",
  130|  20.1k|           src_offset + copy_size,
  131|  20.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|  20.1k|  if (copy_size == 0) {
  ------------------
  |  Branch (136:7): [True: 0, False: 20.1k]
  ------------------
  137|      0|    return;
  138|      0|  }
  139|  20.1k|  std::memcpy(dst_data, data() + src_offset, copy_size);
  140|  20.1k|}
_ZN2bt17MutableByteBuffer5WriteEPKhmm:
  142|  7.85k|void MutableByteBuffer::Write(const uint8_t* data, size_t size, size_t pos) {
  143|  7.85k|  BufferView from(data, size);
  144|  7.85k|  MutableBufferView to = mutable_view(pos);
  145|  7.85k|  from.Copy(&to);
  146|  7.85k|}
_ZN2bt17MutableByteBuffer12mutable_viewEmm:
  148|  23.8k|MutableBufferView MutableByteBuffer::mutable_view(size_t pos, size_t size) {
  149|  23.8k|  PW_CHECK(pos <= this->size(),
  ------------------
  |  |   39|  23.8k|  do {                                                                         \
  |  |   40|  23.8k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 23.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|  23.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  150|  23.8k|           "offset past buffer (pos: %zu, size: %zu)",
  151|  23.8k|           pos,
  152|  23.8k|           this->size());
  153|  23.8k|  return MutableBufferView(mutable_data() + pos,
  154|  23.8k|                           std::min(size, this->size() - pos));
  155|  23.8k|}
_ZN2bt17DynamicByteBufferC2Em:
  170|    229|    : buffer_size_(buffer_size) {
  171|    229|  if (buffer_size == 0) {
  ------------------
  |  Branch (171:7): [True: 0, False: 229]
  ------------------
  172|      0|    return;
  173|      0|  }
  174|       |
  175|       |  // make_unique value-initializes the buffer to 0.
  176|    229|  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|    229|  PW_CHECK(buffer_.get(), "failed to allocate buffer");
  ------------------
  |  |   39|    229|  do {                                                                         \
  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  ------------------
  |  |   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|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  181|    229|}
_ZN2bt17DynamicByteBuffer12mutable_dataEv:
  223|  3.92k|uint8_t* DynamicByteBuffer::mutable_data() { return buffer_.get(); }
_ZNK2bt17DynamicByteBuffer4sizeEv:
  225|  8.08k|size_t DynamicByteBuffer::size() const { return buffer_size_; }
_ZN2bt10BufferViewC2EPKvm:
  280|  25.1k|    : size_(size), bytes_(static_cast<const uint8_t*>(bytes)) {
  281|       |  // If |size| non-zero then |bytes| cannot be nullptr.
  282|  25.1k|  PW_CHECK(!size_ || bytes_, "|bytes_| cannot be nullptr if |size_| > 0");
  ------------------
  |  |   39|  25.1k|  do {                                                                         \
  |  |   40|  50.3k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:11): [True: 0, False: 25.1k]
  |  |  |  Branch (40:11): [True: 25.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|  25.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  283|  25.1k|}
_ZN2bt10BufferViewC2Ev:
  285|  7.85k|BufferView::BufferView() = default;
_ZNK2bt10BufferView4dataEv:
  287|  25.1k|const uint8_t* BufferView::data() const { return bytes_; }
_ZNK2bt10BufferView4sizeEv:
  289|  73.4k|size_t BufferView::size() const { return size_; }
_ZN2bt17MutableBufferViewC2EPvm:
  302|  23.8k|    : size_(size), bytes_(static_cast<uint8_t*>(bytes)) {
  303|       |  // If |size| non-zero then |bytes| cannot be nullptr.
  304|  23.8k|  PW_CHECK(!size_ || bytes_, "|bytes_| cannot be nullptr if |size_| > 0");
  ------------------
  |  |   39|  23.8k|  do {                                                                         \
  |  |   40|  47.6k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:11): [True: 0, False: 23.8k]
  |  |  |  Branch (40:11): [True: 23.8k, 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|  23.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  305|  23.8k|}
_ZNK2bt17MutableBufferView4sizeEv:
  311|  36.5k|size_t MutableBufferView::size() const { return size_; }
_ZN2bt17MutableBufferView12mutable_dataEv:
  319|  24.0k|uint8_t* MutableBufferView::mutable_data() { return bytes_; }

_ZN2bt5l2cap8internal17BasicModeRxEngine10ProcessPduENS0_3PDUE:
   21|    229|ByteBufferPtr BasicModeRxEngine::ProcessPdu(PDU pdu) {
   22|    229|  PW_CHECK(pdu.is_valid());
  ------------------
  |  |   39|    229|  do {                                                                         \
  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  ------------------
  |  |   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|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   23|    229|  auto sdu = std::make_unique<DynamicByteBuffer>(pdu.length());
   24|    229|  pdu.Copy(sdu.get());
   25|    229|  return sdu;
   26|    229|}

LLVMFuzzerTestOneInput:
   20|    229|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   21|    229|  constexpr bt::hci_spec::ConnectionHandle kTestHandle = 0x0001;
   22|    229|  constexpr bt::l2cap::ChannelId kTestChannelId = 0x0001;
   23|    229|  bt::l2cap::Fragmenter fragmenter(kTestHandle);
   24|    229|  bt::l2cap::internal::BasicModeRxEngine rx_engine;
   25|       |
   26|       |  // In production, TxEngines enforce the maximum size before passing PDUs to
   27|       |  // the fragmenter.
   28|    229|  bt::BufferView data_view(
   29|    229|      data,
   30|    229|      std::min(size,
   31|    229|               static_cast<size_t>(bt::l2cap::kMaxBasicFramePayloadSize)));
   32|       |
   33|       |  // The use of a fragmenter, to build a PDU for the receive engine, is
   34|       |  // admittedly counterintuitive. (In actual operation, we use a Fragmenter on
   35|       |  // the transmit path, and a Recombiner on the receive path.) Pragmatically,
   36|       |  // however, the Fragmenter is the easiest way to build a PDU.
   37|       |  //
   38|       |  // Note that using a Fragmenter to build the PDU doesn't decrease the efficacy
   39|       |  // of fuzzing, because the only guarantees provided by the Fragmenter are
   40|       |  // those that are preconditions for RxEngine::ProcessPdu().
   41|    229|  auto pdu = fragmenter.BuildFrame(
   42|    229|      kTestChannelId, data_view, bt::l2cap::FrameCheckSequenceOption::kNoFcs);
   43|    229|  rx_engine.ProcessPdu(std::move(pdu));
   44|    229|  return 0;
   45|    229|}

_ZN2bt5l2cap13OutboundFrameC2EtRKNS_10ByteBufferENS0_24FrameCheckSequenceOptionE:
   43|    229|    : channel_id_(channel_id),
   44|    229|      data_(data.view()),
   45|    229|      fcs_option_(fcs_option),
   46|    229|      fcs_(include_fcs() ? std::optional(MakeFcs()) : std::nullopt) {}
  ------------------
  |  Branch (46:12): [True: 0, False: 229]
  ------------------
_ZNK2bt5l2cap13OutboundFrame4sizeEv:
   48|  12.0k|size_t OutboundFrame::size() const {
   49|  12.0k|  return sizeof(BasicHeader) + data_.size() +
   50|  12.0k|         (include_fcs() ? sizeof(FrameCheckSequence) : 0);
  ------------------
  |  Branch (50:11): [True: 0, False: 12.0k]
  ------------------
   51|  12.0k|}
_ZN2bt5l2cap13OutboundFrame15WriteToFragmentENS_17MutableBufferViewEm:
   54|  3.92k|                                    size_t offset) {
   55|       |  // Build a table of the pages making up the frame's content, in sorted order.
   56|  3.92k|  const StaticByteBuffer header_buffer = MakeBasicHeader();
   57|  3.92k|  const std::optional fcs_buffer =
   58|  3.92k|      include_fcs() ? std::optional(MakeFcs()) : std::nullopt;
  ------------------
  |  Branch (58:7): [True: 0, False: 3.92k]
  ------------------
   59|  3.92k|  const BufferView footer_buffer =
   60|  3.92k|      fcs_buffer ? fcs_buffer->view() : BufferView();
  ------------------
  |  Branch (60:7): [True: 0, False: 3.92k]
  ------------------
   61|  3.92k|  const std::array pages = {
   62|  3.92k|      header_buffer.view(), data_.view(), footer_buffer, BufferView()};
   63|  3.92k|  const std::array offsets = {size_t{0},
   64|  3.92k|                              header_buffer.size(),
   65|  3.92k|                              header_buffer.size() + data_.size(),
   66|  3.92k|                              size()};
   67|  3.92k|  static_assert(pages.size() == offsets.size());
   68|       |
   69|  3.92k|  PW_CHECK(offset <= size());
  ------------------
  |  |   39|  3.92k|  do {                                                                         \
  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  ------------------
  |  |   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|  3.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   70|  3.92k|  size_t output_offset = 0;
   71|       |
   72|       |  // Find the last page whose offset is not greater than the current offset.
   73|  3.92k|  const auto page_iter =
   74|  3.92k|      std::prev(std::upper_bound(offsets.begin(), offsets.end(), offset));
   75|  3.92k|  for (size_t page_index = page_iter - offsets.begin();
   76|  8.08k|       page_index < pages.size();
  ------------------
  |  Branch (76:8): [True: 8.08k, False: 0]
  ------------------
   77|  8.08k|       page_index++) {
   78|  8.08k|    if (fragment_payload.size() - output_offset == 0) {
  ------------------
  |  Branch (78:9): [True: 3.92k, False: 4.15k]
  ------------------
   79|  3.92k|      break;
   80|  3.92k|    }
   81|  4.15k|    const auto& page_buffer = pages[page_index];
   82|  4.15k|    const size_t bytes_copied =
   83|  4.15k|        CopyBounded(fragment_payload.mutable_view(output_offset),
   84|  4.15k|                    page_buffer.view(offset - offsets[page_index]));
   85|  4.15k|    offset += bytes_copied;
   86|  4.15k|    output_offset += bytes_copied;
   87|  4.15k|  }
   88|  3.92k|  PW_CHECK(output_offset <= fragment_payload.size());
  ------------------
  |  |   39|  3.92k|  do {                                                                         \
  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  ------------------
  |  |   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|  3.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   89|  3.92k|}
_ZNK2bt5l2cap13OutboundFrame15MakeBasicHeaderEv:
   91|  3.92k|OutboundFrame::BasicHeaderBuffer OutboundFrame::MakeBasicHeader() const {
   92|       |  // Length is "the length of the entire L2CAP PDU in octets, excluding the
   93|       |  // Length and CID field" (v5.0 Vol 3, Part A, Section 3.3.1)
   94|  3.92k|  const size_t pdu_content_length = size() - sizeof(BasicHeader);
   95|  3.92k|  PW_CHECK(pdu_content_length <=
  ------------------
  |  |   39|  3.92k|  do {                                                                         \
  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  ------------------
  |  |   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|  3.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   96|  3.92k|               std::numeric_limits<decltype(BasicHeader::length)>::max(),
   97|  3.92k|           "PDU payload is too large to be encoded");
   98|  3.92k|  BasicHeader header = {};
   99|  3.92k|  header.length = pw::bytes::ConvertOrderTo(
  100|  3.92k|      cpp20::endian::little, static_cast<uint16_t>(pdu_content_length));
  101|  3.92k|  header.channel_id =
  102|  3.92k|      pw::bytes::ConvertOrderTo(cpp20::endian::little, channel_id_);
  103|  3.92k|  BasicHeaderBuffer buffer;
  104|  3.92k|  buffer.WriteObj(header);
  105|  3.92k|  return buffer;
  106|  3.92k|}
_ZN2bt5l2cap10FragmenterC2Ett:
  122|    229|    : connection_handle_(connection_handle),
  123|    229|      max_acl_payload_size_(max_acl_payload_size) {
  124|    229|  PW_CHECK(connection_handle_ <= hci_spec::kConnectionHandleMax);
  ------------------
  |  |   39|    229|  do {                                                                         \
  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  ------------------
  |  |   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|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  125|    229|  PW_CHECK(max_acl_payload_size_);
  ------------------
  |  |   39|    229|  do {                                                                         \
  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  ------------------
  |  |   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|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  126|    229|  PW_CHECK(max_acl_payload_size_ >= sizeof(BasicHeader));
  ------------------
  |  |   39|    229|  do {                                                                         \
  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  ------------------
  |  |   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|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  127|    229|}
_ZNK2bt5l2cap10Fragmenter10BuildFrameEtRKNS_10ByteBufferENS0_24FrameCheckSequenceOptionEb:
  157|    229|                           bool flushable) const {
  158|    229|  PW_DCHECK(data.size() <= kMaxBasicFramePayloadSize);
  ------------------
  |  |   51|    229|  do {                            \
  |  |   52|    229|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|    229|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    229|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|    229|  do {                                                                         \
  |  |  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  |  |  ------------------
  |  |  |  |   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|    229|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|    229|    }                             \
  |  |   55|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  159|    229|  PW_DCHECK(channel_id);
  ------------------
  |  |   51|    229|  do {                            \
  |  |   52|    229|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|    229|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    229|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|    229|  do {                                                                         \
  |  |  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  |  |  ------------------
  |  |  |  |   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|    229|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|    229|    }                             \
  |  |   55|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  160|       |
  161|    229|  OutboundFrame frame(channel_id, data, fcs_option);
  162|    229|  const size_t frame_size = frame.size();
  163|    229|  const size_t num_fragments = frame_size / max_acl_payload_size_ +
  164|    229|                               (frame_size % max_acl_payload_size_ ? 1 : 0);
  ------------------
  |  Branch (164:33): [True: 217, False: 12]
  ------------------
  165|       |
  166|    229|  PDU pdu;
  167|    229|  size_t processed = 0;
  168|  4.15k|  for (size_t i = 0; i < num_fragments; i++) {
  ------------------
  |  Branch (168:22): [True: 3.92k, False: 229]
  ------------------
  169|  3.92k|    PW_DCHECK(frame_size > processed);
  ------------------
  |  |   51|  3.92k|  do {                            \
  |  |   52|  3.92k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|  3.92k|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|  3.92k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  3.92k|  do {                                                                         \
  |  |  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  |  |  ------------------
  |  |  |  |   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|  3.92k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  3.92k|    }                             \
  |  |   55|  3.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  170|       |
  171|  3.92k|    const size_t fragment_size = std::min(
  172|  3.92k|        frame_size - processed, static_cast<size_t>(max_acl_payload_size_));
  173|  3.92k|    auto pbf =
  174|  3.92k|        (i ? hci_spec::ACLPacketBoundaryFlag::kContinuingFragment
  ------------------
  |  Branch (174:10): [True: 3.70k, False: 229]
  ------------------
  175|  3.92k|           : (flushable ? hci_spec::ACLPacketBoundaryFlag::kFirstFlushable
  ------------------
  |  Branch (175:15): [True: 0, False: 229]
  ------------------
  176|    229|                        : hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable));
  177|       |
  178|       |    // TODO(armansito): allow passing Active Peripheral Broadcast flag when we
  179|       |    // support it.
  180|  3.92k|    auto acl_packet =
  181|  3.92k|        hci::ACLDataPacket::New(connection_handle_,
  182|  3.92k|                                pbf,
  183|  3.92k|                                hci_spec::ACLBroadcastFlag::kPointToPoint,
  184|  3.92k|                                static_cast<uint16_t>(fragment_size));
  185|  3.92k|    PW_DCHECK(acl_packet);
  ------------------
  |  |   51|  3.92k|  do {                            \
  |  |   52|  3.92k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|  3.92k|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|  3.92k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  3.92k|  do {                                                                         \
  |  |  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  |  |  ------------------
  |  |  |  |   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|  3.92k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  3.92k|    }                             \
  |  |   55|  3.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  186|       |
  187|  3.92k|    frame.WriteToFragment(acl_packet->mutable_view()->mutable_payload_data(),
  188|  3.92k|                          processed);
  189|  3.92k|    processed += fragment_size;
  190|       |
  191|  3.92k|    pdu.AppendFragment(std::move(acl_packet));
  192|  3.92k|  }
  193|       |
  194|       |  // The PDU should have been completely processed if we got here.
  195|    229|  PW_DCHECK(processed == frame_size);
  ------------------
  |  |   51|    229|  do {                            \
  |  |   52|    229|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|    229|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    229|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|    229|  do {                                                                         \
  |  |  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  |  |  ------------------
  |  |  |  |   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|    229|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|    229|    }                             \
  |  |   55|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  196|       |
  197|    229|  return pdu;
  198|    229|}
fragmenter.cc:_ZN2bt5l2cap12_GLOBAL__N_111CopyBoundedENS_17MutableBufferViewERKNS_10ByteBufferE:
   32|  4.15k|size_t CopyBounded(MutableBufferView destination, const ByteBuffer& source) {
   33|  4.15k|  const size_t size = std::min(destination.size(), source.size());
   34|  4.15k|  source.Copy(&destination, 0, size);
   35|  4.15k|  return size;
   36|  4.15k|}

_ZN2bt5l2cap3PDUC2EOS1_:
   26|    229|PDU::PDU(PDU&& other) : fragments_(other.ReleaseFragments()) {}
_ZNK2bt5l2cap3PDU4CopyEPNS_17MutableByteBufferEmm:
   35|    229|size_t PDU::Copy(MutableByteBuffer* out_buffer, size_t pos, size_t size) const {
   36|    229|  PW_DCHECK(out_buffer);
  ------------------
  |  |   51|    229|  do {                            \
  |  |   52|    229|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|    229|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    229|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|    229|  do {                                                                         \
  |  |  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  |  |  ------------------
  |  |  |  |   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|    229|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|    229|    }                             \
  |  |   55|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   37|    229|  PW_DCHECK(pos <= length());
  ------------------
  |  |   51|    229|  do {                            \
  |  |   52|    229|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|    229|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    229|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|    229|  do {                                                                         \
  |  |  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  |  |  ------------------
  |  |  |  |   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|    229|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|    229|    }                             \
  |  |   55|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   38|    229|  PW_DCHECK(is_valid());
  ------------------
  |  |   51|    229|  do {                            \
  |  |   52|    229|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|    229|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    229|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|    229|  do {                                                                         \
  |  |  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  |  |  ------------------
  |  |  |  |   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|    229|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|    229|    }                             \
  |  |   55|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   39|       |
   40|    229|  size_t remaining = std::min(size, length() - pos);
   41|    229|  PW_DCHECK(out_buffer->size() >= remaining);
  ------------------
  |  |   51|    229|  do {                            \
  |  |   52|    229|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|    229|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    229|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|    229|  do {                                                                         \
  |  |  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  |  |  ------------------
  |  |  |  |   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|    229|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|    229|    }                             \
  |  |   55|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   42|    229|  if (!remaining) {
  ------------------
  |  Branch (42:7): [True: 0, False: 229]
  ------------------
   43|      0|    return 0;
   44|      0|  }
   45|       |
   46|    229|  bool found = false;
   47|    229|  size_t offset = 0u;
   48|  4.15k|  for (auto iter = fragments_.begin(); iter != fragments_.end() && remaining;
  ------------------
  |  Branch (48:40): [True: 3.92k, False: 229]
  |  Branch (48:40): [True: 3.92k, False: 229]
  |  Branch (48:68): [True: 3.92k, False: 0]
  ------------------
   49|  3.92k|       ++iter) {
   50|  3.92k|    auto payload = (*iter)->view().payload_data();
   51|       |
   52|       |    // Skip the Basic L2CAP header for the first fragment.
   53|  3.92k|    if (iter == fragments_.begin()) {
  ------------------
  |  Branch (53:9): [True: 229, False: 3.70k]
  ------------------
   54|    229|      payload = payload.view(sizeof(BasicHeader));
   55|    229|    }
   56|       |
   57|       |    // We first find the beginning fragment based on |pos|.
   58|  3.92k|    if (!found) {
  ------------------
  |  Branch (58:9): [True: 229, False: 3.70k]
  ------------------
   59|    229|      size_t fragment_size = payload.size();
   60|    229|      if (pos >= fragment_size) {
  ------------------
  |  Branch (60:11): [True: 0, False: 229]
  ------------------
   61|      0|        pos -= fragment_size;
   62|      0|        continue;
   63|      0|      }
   64|       |
   65|       |      // The beginning fragment has been found.
   66|    229|      found = true;
   67|    229|    }
   68|       |
   69|       |    // Calculate how much to read from the current fragment
   70|  3.92k|    size_t write_size = std::min(payload.size() - pos, remaining);
   71|       |
   72|       |    // Read the fragment into out_buffer->mutable_data() + offset.
   73|  3.92k|    out_buffer->Write(payload.data() + pos, write_size, offset);
   74|       |
   75|       |    // Clear |pos| after using it on the first fragment as all successive
   76|       |    // fragments are read from the beginning.
   77|  3.92k|    if (pos)
  ------------------
  |  Branch (77:9): [True: 0, False: 3.92k]
  ------------------
   78|      0|      pos = 0u;
   79|       |
   80|  3.92k|    offset += write_size;
   81|  3.92k|    remaining -= write_size;
   82|  3.92k|  }
   83|       |
   84|    229|  return offset;
   85|    229|}
_ZN2bt5l2cap3PDU16ReleaseFragmentsEv:
   87|    229|PDU::FragmentList PDU::ReleaseFragments() {
   88|    229|  auto out_list = std::move(fragments_);
   89|       |
   90|    229|  PW_DCHECK(!is_valid());
  ------------------
  |  |   51|    229|  do {                            \
  |  |   52|    229|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|    229|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    229|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|    229|  do {                                                                         \
  |  |  |  |   40|    229|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 229]
  |  |  |  |  ------------------
  |  |  |  |   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|    229|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|    229|    }                             \
  |  |   55|    229|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   91|    229|  return out_list;
   92|    229|}
_ZNK2bt5l2cap3PDU12basic_headerEv:
   94|    687|const BasicHeader& PDU::basic_header() const {
   95|    687|  PW_DCHECK(!fragments_.empty());
  ------------------
  |  |   51|    687|  do {                            \
  |  |   52|    687|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|    687|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    687|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|    687|  do {                                                                         \
  |  |  |  |   40|    687|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 687]
  |  |  |  |  ------------------
  |  |  |  |   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|    687|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|    687|    }                             \
  |  |   55|    687|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   96|    687|  const auto& fragment = *fragments_.begin();
   97|       |
   98|    687|  PW_DCHECK(fragment->packet_boundary_flag() !=
  ------------------
  |  |   51|    687|  do {                            \
  |  |   52|    687|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|    687|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    687|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|    687|  do {                                                                         \
  |  |  |  |   40|    687|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 687]
  |  |  |  |  ------------------
  |  |  |  |   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|    687|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|    687|    }                             \
  |  |   55|    687|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   99|    687|            hci_spec::ACLPacketBoundaryFlag::kContinuingFragment);
  100|    687|  return fragment->view().payload<BasicHeader>();
  101|    687|}
_ZN2bt5l2cap3PDU14AppendFragmentENSt3__110unique_ptrINS_3hci6PacketINS_8hci_spec13ACLDataHeaderEEENS2_14default_deleteIS8_EEEE:
  103|  3.92k|void PDU::AppendFragment(hci::ACLDataPacketPtr fragment) {
  104|  3.92k|  PW_DCHECK(fragment);
  ------------------
  |  |   51|  3.92k|  do {                            \
  |  |   52|  3.92k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|  3.92k|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|  3.92k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  3.92k|  do {                                                                         \
  |  |  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  |  |  ------------------
  |  |  |  |   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|  3.92k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  3.92k|    }                             \
  |  |   55|  3.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  105|  3.92k|  PW_DCHECK(!is_valid() || (*fragments_.begin())->connection_handle() ==
  ------------------
  |  |   51|  3.92k|  do {                            \
  |  |   52|  3.92k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|  3.92k|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|  3.92k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  3.92k|  do {                                                                         \
  |  |  |  |   40|  7.62k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  |  |  |  Branch (40:11): [True: 229, False: 3.70k]
  |  |  |  |  |  Branch (40:11): [True: 3.70k, 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|  3.92k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  3.92k|    }                             \
  |  |   55|  3.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  106|  3.92k|                               fragment->connection_handle());
  107|  3.92k|  fragments_.push_back(std::move(fragment));
  108|  3.92k|}

_ZN2bt3hci6PacketINS_8hci_spec13ACLDataHeaderEE3NewEtNS2_21ACLPacketBoundaryFlagENS2_16ACLBroadcastFlagEt:
   68|  3.92k|    uint16_t payload_size) {
   69|  3.92k|  auto packet = NewACLDataPacket(payload_size);
   70|  3.92k|  if (!packet)
  ------------------
  |  Branch (70:7): [True: 0, False: 3.92k]
  ------------------
   71|      0|    return nullptr;
   72|       |
   73|  3.92k|  packet->WriteHeader(connection_handle, packet_boundary_flag, broadcast_flag);
   74|  3.92k|  return packet;
   75|  3.92k|}
_ZNK2bt3hci6PacketINS_8hci_spec13ACLDataHeaderEE17connection_handleEv:
   77|  7.40k|hci_spec::ConnectionHandle ACLDataPacket::connection_handle() const {
   78|       |  // Return the lower 12-bits of the first two octets.
   79|  7.40k|  return pw::bytes::ConvertOrderFrom(
   80|  7.40k|             cpp20::endian::little,
   81|  7.40k|             ACLDataPacket::view().header().handle_and_flags) &
   82|  7.40k|         0x0FFF;
   83|  7.40k|}
_ZNK2bt3hci6PacketINS_8hci_spec13ACLDataHeaderEE20packet_boundary_flagEv:
   85|    687|hci_spec::ACLPacketBoundaryFlag ACLDataPacket::packet_boundary_flag() const {
   86|       |  // Return bits 4-5 in the higher octet of |handle_and_flags| or
   87|       |  // "0b00xx000000000000".
   88|    687|  return static_cast<hci_spec::ACLPacketBoundaryFlag>(
   89|    687|      (pw::bytes::ConvertOrderFrom(
   90|    687|           cpp20::endian::little,
   91|    687|           ACLDataPacket::view().header().handle_and_flags) >>
   92|    687|       12) &
   93|    687|      0x0003);
   94|    687|}
_ZN2bt3hci6PacketINS_8hci_spec13ACLDataHeaderEE11WriteHeaderEtNS2_21ACLPacketBoundaryFlagENS2_16ACLBroadcastFlagE:
  113|  3.92k|    hci_spec::ACLBroadcastFlag broadcast_flag) {
  114|       |  // Must fit inside 12-bits.
  115|  3.92k|  PW_DCHECK(connection_handle <= 0x0FFF);
  ------------------
  |  |   51|  3.92k|  do {                            \
  |  |   52|  3.92k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |   53|  3.92k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  3.92k|  do {                                                                         \
  |  |  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  |  |  ------------------
  |  |  |  |   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.92k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  3.92k|    }                             \
  |  |   55|  3.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|       |
  117|       |  // Must fit inside 2-bits.
  118|  3.92k|  PW_DCHECK(static_cast<uint8_t>(packet_boundary_flag) <= 0x03);
  ------------------
  |  |   51|  3.92k|  do {                            \
  |  |   52|  3.92k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |   53|  3.92k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  3.92k|  do {                                                                         \
  |  |  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  |  |  ------------------
  |  |  |  |   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.92k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  3.92k|    }                             \
  |  |   55|  3.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  119|  3.92k|  PW_DCHECK(static_cast<uint8_t>(broadcast_flag) <= 0x03);
  ------------------
  |  |   51|  3.92k|  do {                            \
  |  |   52|  3.92k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |   53|  3.92k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  3.92k|  do {                                                                         \
  |  |  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  |  |  ------------------
  |  |  |  |   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.92k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  3.92k|    }                             \
  |  |   55|  3.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  120|       |
  121|       |  // Bitwise OR causes int promotion, so the result must be explicitly casted.
  122|  3.92k|  uint16_t handle_and_flags = static_cast<uint16_t>(
  123|  3.92k|      connection_handle | (static_cast<uint16_t>(packet_boundary_flag) << 12) |
  124|  3.92k|      (static_cast<uint16_t>(broadcast_flag) << 14));
  125|  3.92k|  mutable_view()->mutable_header()->handle_and_flags =
  126|  3.92k|      pw::bytes::ConvertOrderTo(cpp20::endian::little, handle_and_flags);
  127|  3.92k|  mutable_view()->mutable_header()->data_total_length = static_cast<uint16_t>(
  128|  3.92k|      pw::bytes::ConvertOrderTo(cpp20::endian::little, view().payload_size()));
  129|  3.92k|}
acl_data_packet.cc:_ZN2bt3hci12_GLOBAL__N_116NewACLDataPacketEm:
   39|  3.92k|ACLDataPacketPtr NewACLDataPacket(size_t payload_size) {
   40|  3.92k|  PW_CHECK(payload_size <= allocators::kLargeACLDataPayloadSize,
  ------------------
  |  |   39|  3.92k|  do {                                                                         \
  |  |   40|  3.92k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 3.92k]
  |  |  ------------------
  |  |   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.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   41|  3.92k|           "payload size %zu too large (allowed = %zu)",
   42|  3.92k|           payload_size,
   43|  3.92k|           allocators::kLargeACLDataPayloadSize);
   44|       |
   45|  3.92k|  if (payload_size <= allocators::kSmallACLDataPayloadSize) {
  ------------------
  |  Branch (45:7): [True: 114, False: 3.81k]
  ------------------
   46|    114|    return std::make_unique<SmallACLDataPacket>(payload_size);
   47|    114|  }
   48|       |
   49|  3.81k|  if (payload_size <= allocators::kMediumACLDataPayloadSize) {
  ------------------
  |  Branch (49:7): [True: 31, False: 3.78k]
  ------------------
   50|     31|    return std::make_unique<MediumACLDataPacket>(payload_size);
   51|     31|  }
   52|       |
   53|  3.78k|  return std::make_unique<LargeACLDataPacket>(payload_size);
   54|  3.81k|}