_ZN2pw6assert8internal13ConvertToTypeIPKvNS_8protobuf13StreamDecoderEEES4_PT0_:
  200|  6.50k|constexpr const void* ConvertToType(U* value) {
  201|       |  if constexpr (std::is_function<U>()) {
  202|       |    return reinterpret_cast<const void*>(value);
  203|  6.50k|  } else {
  204|  6.50k|    return static_cast<const void*>(value);
  205|  6.50k|  }
  206|  6.50k|}

_ZN2pw8protobuf13StreamDecoderC2ERNS_6stream6ReaderE:
  107|  2.32k|      : StreamDecoder(reader, std::numeric_limits<size_t>::max()) {}
_ZN2pw8protobuf13StreamDecoderC2ERNS_6stream6ReaderEm:
  113|  2.32k|      : reader_(reader),
  114|  2.32k|        stream_bounds_({0, length}),
  115|  2.32k|        position_(0),
  116|  2.32k|        current_field_(kInitialFieldKey),
  117|  2.32k|        delimited_field_size_(0),
  118|  2.32k|        delimited_field_offset_(0),
  119|  2.32k|        parent_(nullptr),
  120|  2.32k|        field_consumed_(true),
  121|  2.32k|        nested_reader_open_(false),
  122|  2.32k|        status_(OkStatus()) {}
_ZN2pw8protobuf13StreamDecoder10ReadUint32Ev:
  182|    429|  Result<uint32_t> ReadUint32() {
  183|    429|    return ReadVarintField<uint32_t>(internal::VarintType::kUnsigned);
  184|    429|  }
_ZN2pw8protobuf13StreamDecoder15ReadVarintFieldIjEENS_6ResultIT_EENS0_8internal10VarintTypeE:
  603|    429|  Result<T> ReadVarintField(internal::VarintType decode_type) {
  604|    429|    static_assert(
  605|    429|        std::is_same_v<T, bool> || std::is_same_v<T, uint32_t> ||
  606|    429|            std::is_same_v<T, int32_t> || std::is_same_v<T, uint64_t> ||
  607|    429|            std::is_same_v<T, int64_t>,
  608|    429|        "Protobuf varints must be of type bool, uint32_t, int32_t, uint64_t, "
  609|    429|        "or int64_t");
  610|    429|    using DecodedValue =
  611|    429|        std::conditional_t<std::is_signed<T>::value, int64_t, uint64_t>;
  612|    429|    static_assert(sizeof(DecodedValue) >= sizeof(T));
  613|       |
  614|    429|    DecodedValue result;
  615|    429|    if (Status status =
  616|    429|            ReadVarintField(as_writable_bytes(span(&result, 1)), decode_type);
  617|    429|        !status.ok()) {
  ------------------
  |  Branch (617:9): [True: 67, False: 362]
  ------------------
  618|     67|      return status;
  619|     67|    }
  620|    362|    if (result > static_cast<DecodedValue>(std::numeric_limits<T>::max()) ||
  ------------------
  |  Branch (620:9): [True: 79, False: 283]
  ------------------
  621|    362|        result < static_cast<DecodedValue>(std::numeric_limits<T>::lowest())) {
  ------------------
  |  Branch (621:9): [True: 0, False: 283]
  ------------------
  622|       |      // When a varint is too big to fit in an integer, the decoder returns
  623|       |      // FAILED_PRECONDITION, so this mirrors that behavior.
  624|     79|      return Status::FailedPrecondition();
  625|     79|    }
  626|    283|    return static_cast<T>(result);
  627|    362|  }
_ZN2pw8protobuf13StreamDecoder16ReadPackedUint32ENS_4spanIjLm18446744073709551615EEE:
  191|    414|  StatusWithSize ReadPackedUint32(span<uint32_t> out) {
  192|    414|    return ReadPackedVarintField(as_writable_bytes(out),
  193|    414|                                 sizeof(uint32_t),
  194|    414|                                 internal::VarintType::kUnsigned);
  195|    414|  }
_ZN2pw8protobuf13StreamDecoder10ReadUint64Ev:
  227|    225|  Result<uint64_t> ReadUint64() {
  228|    225|    return ReadVarintField<uint64_t>(internal::VarintType::kUnsigned);
  229|    225|  }
_ZN2pw8protobuf13StreamDecoder15ReadVarintFieldImEENS_6ResultIT_EENS0_8internal10VarintTypeE:
  603|    225|  Result<T> ReadVarintField(internal::VarintType decode_type) {
  604|    225|    static_assert(
  605|    225|        std::is_same_v<T, bool> || std::is_same_v<T, uint32_t> ||
  606|    225|            std::is_same_v<T, int32_t> || std::is_same_v<T, uint64_t> ||
  607|    225|            std::is_same_v<T, int64_t>,
  608|    225|        "Protobuf varints must be of type bool, uint32_t, int32_t, uint64_t, "
  609|    225|        "or int64_t");
  610|    225|    using DecodedValue =
  611|    225|        std::conditional_t<std::is_signed<T>::value, int64_t, uint64_t>;
  612|    225|    static_assert(sizeof(DecodedValue) >= sizeof(T));
  613|       |
  614|    225|    DecodedValue result;
  615|    225|    if (Status status =
  616|    225|            ReadVarintField(as_writable_bytes(span(&result, 1)), decode_type);
  617|    225|        !status.ok()) {
  ------------------
  |  Branch (617:9): [True: 22, False: 203]
  ------------------
  618|     22|      return status;
  619|     22|    }
  620|    203|    if (result > static_cast<DecodedValue>(std::numeric_limits<T>::max()) ||
  ------------------
  |  Branch (620:9): [True: 0, False: 203]
  ------------------
  621|    203|        result < static_cast<DecodedValue>(std::numeric_limits<T>::lowest())) {
  ------------------
  |  Branch (621:9): [True: 0, False: 203]
  ------------------
  622|       |      // When a varint is too big to fit in an integer, the decoder returns
  623|       |      // FAILED_PRECONDITION, so this mirrors that behavior.
  624|      0|      return Status::FailedPrecondition();
  625|      0|    }
  626|    203|    return static_cast<T>(result);
  627|    203|  }
_ZN2pw8protobuf13StreamDecoder16ReadPackedUint64ENS_4spanImLm18446744073709551615EEE:
  237|    535|  StatusWithSize ReadPackedUint64(span<uint64_t> out) {
  238|    535|    return ReadPackedVarintField(as_writable_bytes(out),
  239|    535|                                 sizeof(uint64_t),
  240|    535|                                 internal::VarintType::kUnsigned);
  241|    535|  }
_ZN2pw8protobuf13StreamDecoder9ReadInt32Ev:
  161|    470|  Result<int32_t> ReadInt32() {
  162|    470|    return ReadVarintField<int32_t>(internal::VarintType::kNormal);
  163|    470|  }
_ZN2pw8protobuf13StreamDecoder15ReadVarintFieldIiEENS_6ResultIT_EENS0_8internal10VarintTypeE:
  603|    912|  Result<T> ReadVarintField(internal::VarintType decode_type) {
  604|    912|    static_assert(
  605|    912|        std::is_same_v<T, bool> || std::is_same_v<T, uint32_t> ||
  606|    912|            std::is_same_v<T, int32_t> || std::is_same_v<T, uint64_t> ||
  607|    912|            std::is_same_v<T, int64_t>,
  608|    912|        "Protobuf varints must be of type bool, uint32_t, int32_t, uint64_t, "
  609|    912|        "or int64_t");
  610|    912|    using DecodedValue =
  611|    912|        std::conditional_t<std::is_signed<T>::value, int64_t, uint64_t>;
  612|    912|    static_assert(sizeof(DecodedValue) >= sizeof(T));
  613|       |
  614|    912|    DecodedValue result;
  615|    912|    if (Status status =
  616|    912|            ReadVarintField(as_writable_bytes(span(&result, 1)), decode_type);
  617|    912|        !status.ok()) {
  ------------------
  |  Branch (617:9): [True: 105, False: 807]
  ------------------
  618|    105|      return status;
  619|    105|    }
  620|    807|    if (result > static_cast<DecodedValue>(std::numeric_limits<T>::max()) ||
  ------------------
  |  Branch (620:9): [True: 68, False: 739]
  ------------------
  621|    807|        result < static_cast<DecodedValue>(std::numeric_limits<T>::lowest())) {
  ------------------
  |  Branch (621:9): [True: 183, False: 556]
  ------------------
  622|       |      // When a varint is too big to fit in an integer, the decoder returns
  623|       |      // FAILED_PRECONDITION, so this mirrors that behavior.
  624|    251|      return Status::FailedPrecondition();
  625|    251|    }
  626|    556|    return static_cast<T>(result);
  627|    807|  }
_ZN2pw8protobuf13StreamDecoder15ReadPackedInt32ENS_4spanIiLm18446744073709551615EEE:
  170|    319|  StatusWithSize ReadPackedInt32(span<int32_t> out) {
  171|    319|    return ReadPackedVarintField(
  172|    319|        as_writable_bytes(out), sizeof(int32_t), internal::VarintType::kNormal);
  173|    319|  }
_ZN2pw8protobuf13StreamDecoder9ReadInt64Ev:
  205|    225|  Result<int64_t> ReadInt64() {
  206|    225|    return ReadVarintField<int64_t>(internal::VarintType::kNormal);
  207|    225|  }
_ZN2pw8protobuf13StreamDecoder15ReadVarintFieldIlEENS_6ResultIT_EENS0_8internal10VarintTypeE:
  603|    518|  Result<T> ReadVarintField(internal::VarintType decode_type) {
  604|    518|    static_assert(
  605|    518|        std::is_same_v<T, bool> || std::is_same_v<T, uint32_t> ||
  606|    518|            std::is_same_v<T, int32_t> || std::is_same_v<T, uint64_t> ||
  607|    518|            std::is_same_v<T, int64_t>,
  608|    518|        "Protobuf varints must be of type bool, uint32_t, int32_t, uint64_t, "
  609|    518|        "or int64_t");
  610|    518|    using DecodedValue =
  611|    518|        std::conditional_t<std::is_signed<T>::value, int64_t, uint64_t>;
  612|    518|    static_assert(sizeof(DecodedValue) >= sizeof(T));
  613|       |
  614|    518|    DecodedValue result;
  615|    518|    if (Status status =
  616|    518|            ReadVarintField(as_writable_bytes(span(&result, 1)), decode_type);
  617|    518|        !status.ok()) {
  ------------------
  |  Branch (617:9): [True: 105, False: 413]
  ------------------
  618|    105|      return status;
  619|    105|    }
  620|    413|    if (result > static_cast<DecodedValue>(std::numeric_limits<T>::max()) ||
  ------------------
  |  Branch (620:9): [True: 0, False: 413]
  ------------------
  621|    413|        result < static_cast<DecodedValue>(std::numeric_limits<T>::lowest())) {
  ------------------
  |  Branch (621:9): [True: 0, False: 413]
  ------------------
  622|       |      // When a varint is too big to fit in an integer, the decoder returns
  623|       |      // FAILED_PRECONDITION, so this mirrors that behavior.
  624|      0|      return Status::FailedPrecondition();
  625|      0|    }
  626|    413|    return static_cast<T>(result);
  627|    413|  }
_ZN2pw8protobuf13StreamDecoder15ReadPackedInt64ENS_4spanIlLm18446744073709551615EEE:
  215|    344|  StatusWithSize ReadPackedInt64(span<int64_t> out) {
  216|    344|    return ReadPackedVarintField(
  217|    344|        as_writable_bytes(out), sizeof(int64_t), internal::VarintType::kNormal);
  218|    344|  }
_ZN2pw8protobuf13StreamDecoder10ReadSint32Ev:
  251|    442|  Result<int32_t> ReadSint32() {
  252|    442|    return ReadVarintField<int32_t>(internal::VarintType::kZigZag);
  253|    442|  }
_ZN2pw8protobuf13StreamDecoder16ReadPackedSint32ENS_4spanIiLm18446744073709551615EEE:
  261|    509|  StatusWithSize ReadPackedSint32(span<int32_t> out) {
  262|    509|    return ReadPackedVarintField(
  263|    509|        as_writable_bytes(out), sizeof(int32_t), internal::VarintType::kZigZag);
  264|    509|  }
_ZN2pw8protobuf13StreamDecoder10ReadSint64Ev:
  273|    293|  Result<int64_t> ReadSint64() {
  274|    293|    return ReadVarintField<int64_t>(internal::VarintType::kZigZag);
  275|    293|  }
_ZN2pw8protobuf13StreamDecoder16ReadPackedSint64ENS_4spanIlLm18446744073709551615EEE:
  283|    335|  StatusWithSize ReadPackedSint64(span<int64_t> out) {
  284|    335|    return ReadPackedVarintField(
  285|    335|        as_writable_bytes(out), sizeof(int64_t), internal::VarintType::kZigZag);
  286|    335|  }
_ZN2pw8protobuf13StreamDecoder8ReadBoolEv:
  295|    365|  Result<bool> ReadBool() {
  296|    365|    return ReadVarintField<bool>(internal::VarintType::kUnsigned);
  297|    365|  }
_ZN2pw8protobuf13StreamDecoder15ReadVarintFieldIbEENS_6ResultIT_EENS0_8internal10VarintTypeE:
  603|    365|  Result<T> ReadVarintField(internal::VarintType decode_type) {
  604|    365|    static_assert(
  605|    365|        std::is_same_v<T, bool> || std::is_same_v<T, uint32_t> ||
  606|    365|            std::is_same_v<T, int32_t> || std::is_same_v<T, uint64_t> ||
  607|    365|            std::is_same_v<T, int64_t>,
  608|    365|        "Protobuf varints must be of type bool, uint32_t, int32_t, uint64_t, "
  609|    365|        "or int64_t");
  610|    365|    using DecodedValue =
  611|    365|        std::conditional_t<std::is_signed<T>::value, int64_t, uint64_t>;
  612|    365|    static_assert(sizeof(DecodedValue) >= sizeof(T));
  613|       |
  614|    365|    DecodedValue result;
  615|    365|    if (Status status =
  616|    365|            ReadVarintField(as_writable_bytes(span(&result, 1)), decode_type);
  617|    365|        !status.ok()) {
  ------------------
  |  Branch (617:9): [True: 27, False: 338]
  ------------------
  618|     27|      return status;
  619|     27|    }
  620|    338|    if (result > static_cast<DecodedValue>(std::numeric_limits<T>::max()) ||
  ------------------
  |  Branch (620:9): [True: 142, False: 196]
  ------------------
  621|    338|        result < static_cast<DecodedValue>(std::numeric_limits<T>::lowest())) {
  ------------------
  |  Branch (621:9): [True: 0, False: 196]
  ------------------
  622|       |      // When a varint is too big to fit in an integer, the decoder returns
  623|       |      // FAILED_PRECONDITION, so this mirrors that behavior.
  624|    142|      return Status::FailedPrecondition();
  625|    142|    }
  626|    196|    return static_cast<T>(result);
  627|    338|  }
_ZN2pw8protobuf13StreamDecoder11ReadFixed32Ev:
  317|    312|  Result<uint32_t> ReadFixed32() { return ReadFixedField<uint32_t>(); }
_ZN2pw8protobuf13StreamDecoder14ReadFixedFieldIjEENS_6ResultIT_EEv:
  632|    312|  Result<T> ReadFixedField() {
  633|    312|    static_assert(
  634|    312|        sizeof(T) == sizeof(uint32_t) || sizeof(T) == sizeof(uint64_t),
  635|    312|        "Protobuf fixed-size fields must be 32- or 64-bit");
  636|       |
  637|    312|    T result;
  638|    312|    if (Status status = ReadFixedField(as_writable_bytes(span(&result, 1)));
  639|    312|        !status.ok()) {
  ------------------
  |  Branch (639:9): [True: 9, False: 303]
  ------------------
  640|      9|      return status;
  641|      9|    }
  642|       |
  643|    303|    return result;
  644|    312|  }
_ZN2pw8protobuf13StreamDecoder17ReadPackedFixed32ENS_4spanIjLm18446744073709551615EEE:
  323|    300|  StatusWithSize ReadPackedFixed32(span<uint32_t> out) {
  324|    300|    return ReadPackedFixedField(as_writable_bytes(out), sizeof(uint32_t));
  325|    300|  }
_ZN2pw8protobuf13StreamDecoder11ReadFixed64Ev:
  334|    210|  Result<uint64_t> ReadFixed64() { return ReadFixedField<uint64_t>(); }
_ZN2pw8protobuf13StreamDecoder14ReadFixedFieldImEENS_6ResultIT_EEv:
  632|    210|  Result<T> ReadFixedField() {
  633|    210|    static_assert(
  634|    210|        sizeof(T) == sizeof(uint32_t) || sizeof(T) == sizeof(uint64_t),
  635|    210|        "Protobuf fixed-size fields must be 32- or 64-bit");
  636|       |
  637|    210|    T result;
  638|    210|    if (Status status = ReadFixedField(as_writable_bytes(span(&result, 1)));
  639|    210|        !status.ok()) {
  ------------------
  |  Branch (639:9): [True: 10, False: 200]
  ------------------
  640|     10|      return status;
  641|     10|    }
  642|       |
  643|    200|    return result;
  644|    210|  }
_ZN2pw8protobuf13StreamDecoder17ReadPackedFixed64ENS_4spanImLm18446744073709551615EEE:
  340|    639|  StatusWithSize ReadPackedFixed64(span<uint64_t> out) {
  341|    639|    return ReadPackedFixedField(as_writable_bytes(out), sizeof(uint64_t));
  342|    639|  }
_ZN2pw8protobuf13StreamDecoder12ReadSfixed32Ev:
  351|    404|  Result<int32_t> ReadSfixed32() { return ReadFixedField<int32_t>(); }
_ZN2pw8protobuf13StreamDecoder14ReadFixedFieldIiEENS_6ResultIT_EEv:
  632|    404|  Result<T> ReadFixedField() {
  633|    404|    static_assert(
  634|    404|        sizeof(T) == sizeof(uint32_t) || sizeof(T) == sizeof(uint64_t),
  635|    404|        "Protobuf fixed-size fields must be 32- or 64-bit");
  636|       |
  637|    404|    T result;
  638|    404|    if (Status status = ReadFixedField(as_writable_bytes(span(&result, 1)));
  639|    404|        !status.ok()) {
  ------------------
  |  Branch (639:9): [True: 9, False: 395]
  ------------------
  640|      9|      return status;
  641|      9|    }
  642|       |
  643|    395|    return result;
  644|    404|  }
_ZN2pw8protobuf13StreamDecoder18ReadPackedSfixed32ENS_4spanIiLm18446744073709551615EEE:
  357|    320|  StatusWithSize ReadPackedSfixed32(span<int32_t> out) {
  358|    320|    return ReadPackedFixedField(as_writable_bytes(out), sizeof(int32_t));
  359|    320|  }
_ZN2pw8protobuf13StreamDecoder12ReadSfixed64Ev:
  368|    210|  Result<int64_t> ReadSfixed64() { return ReadFixedField<int64_t>(); }
_ZN2pw8protobuf13StreamDecoder14ReadFixedFieldIlEENS_6ResultIT_EEv:
  632|    210|  Result<T> ReadFixedField() {
  633|    210|    static_assert(
  634|    210|        sizeof(T) == sizeof(uint32_t) || sizeof(T) == sizeof(uint64_t),
  635|    210|        "Protobuf fixed-size fields must be 32- or 64-bit");
  636|       |
  637|    210|    T result;
  638|    210|    if (Status status = ReadFixedField(as_writable_bytes(span(&result, 1)));
  639|    210|        !status.ok()) {
  ------------------
  |  Branch (639:9): [True: 11, False: 199]
  ------------------
  640|     11|      return status;
  641|     11|    }
  642|       |
  643|    199|    return result;
  644|    210|  }
_ZN2pw8protobuf13StreamDecoder18ReadPackedSfixed64ENS_4spanIlLm18446744073709551615EEE:
  374|    326|  StatusWithSize ReadPackedSfixed64(span<int64_t> out) {
  375|    326|    return ReadPackedFixedField(as_writable_bytes(out), sizeof(int64_t));
  376|    326|  }
_ZN2pw8protobuf13StreamDecoder9ReadFloatEv:
  385|    301|  Result<float> ReadFloat() {
  386|    301|    static_assert(sizeof(float) == sizeof(uint32_t),
  387|    301|                  "Float and uint32_t must be the same size for protobufs");
  388|    301|    return ReadFixedField<float>();
  389|    301|  }
_ZN2pw8protobuf13StreamDecoder14ReadFixedFieldIfEENS_6ResultIT_EEv:
  632|    301|  Result<T> ReadFixedField() {
  633|    301|    static_assert(
  634|    301|        sizeof(T) == sizeof(uint32_t) || sizeof(T) == sizeof(uint64_t),
  635|    301|        "Protobuf fixed-size fields must be 32- or 64-bit");
  636|       |
  637|    301|    T result;
  638|    301|    if (Status status = ReadFixedField(as_writable_bytes(span(&result, 1)));
  639|    301|        !status.ok()) {
  ------------------
  |  Branch (639:9): [True: 8, False: 293]
  ------------------
  640|      8|      return status;
  641|      8|    }
  642|       |
  643|    293|    return result;
  644|    301|  }
_ZN2pw8protobuf13StreamDecoder15ReadPackedFloatENS_4spanIfLm18446744073709551615EEE:
  395|    371|  StatusWithSize ReadPackedFloat(span<float> out) {
  396|    371|    static_assert(sizeof(float) == sizeof(uint32_t),
  397|    371|                  "Float and uint32_t must be the same size for protobufs");
  398|    371|    return ReadPackedFixedField(as_writable_bytes(out), sizeof(float));
  399|    371|  }
_ZN2pw8protobuf13StreamDecoder10ReadDoubleEv:
  408|    211|  Result<double> ReadDouble() {
  409|    211|    static_assert(sizeof(double) == sizeof(uint64_t),
  410|    211|                  "Double and uint64_t must be the same size for protobufs");
  411|    211|    return ReadFixedField<double>();
  412|    211|  }
_ZN2pw8protobuf13StreamDecoder14ReadFixedFieldIdEENS_6ResultIT_EEv:
  632|    211|  Result<T> ReadFixedField() {
  633|    211|    static_assert(
  634|    211|        sizeof(T) == sizeof(uint32_t) || sizeof(T) == sizeof(uint64_t),
  635|    211|        "Protobuf fixed-size fields must be 32- or 64-bit");
  636|       |
  637|    211|    T result;
  638|    211|    if (Status status = ReadFixedField(as_writable_bytes(span(&result, 1)));
  639|    211|        !status.ok()) {
  ------------------
  |  Branch (639:9): [True: 7, False: 204]
  ------------------
  640|      7|      return status;
  641|      7|    }
  642|       |
  643|    204|    return result;
  644|    211|  }
_ZN2pw8protobuf13StreamDecoder16ReadPackedDoubleENS_4spanIdLm18446744073709551615EEE:
  418|    350|  StatusWithSize ReadPackedDouble(span<double> out) {
  419|    350|    static_assert(sizeof(double) == sizeof(uint64_t),
  420|    350|                  "Double and uint64_t must be the same size for protobufs");
  421|    350|    return ReadPackedFixedField(as_writable_bytes(out), sizeof(double));
  422|    350|  }
_ZN2pw8protobuf13StreamDecoder9ReadBytesENS_4spanISt4byteLm18446744073709551615EEE:
  451|  1.19k|  StatusWithSize ReadBytes(span<std::byte> out) {
  452|  1.19k|    return ReadDelimitedField(out);
  453|  1.19k|  }
_ZN2pw8protobuf13StreamDecoder10ReadStringENS_4spanIcLm18446744073709551615EEE:
  438|    420|  StatusWithSize ReadString(span<char> out) {
  439|    420|    return ReadBytes(as_writable_bytes(out));
  440|    420|  }
_ZN2pw8protobuf13StreamDecoderC2ERNS_6stream6ReaderEPS1_mm:
  554|  3.22k|      : reader_(reader),
  555|  3.22k|        stream_bounds_({low, high}),
  556|  3.22k|        position_(parent->position_),
  557|  3.22k|        current_field_(kInitialFieldKey),
  558|  3.22k|        delimited_field_size_(0),
  559|  3.22k|        delimited_field_offset_(0),
  560|  3.22k|        parent_(parent),
  561|  3.22k|        field_consumed_(true),
  562|  3.22k|        nested_reader_open_(false),
  563|  3.22k|        status_(OkStatus()) {}
_ZN2pw8protobuf13StreamDecoderC2ERNS_6stream6ReaderEPS1_NS_6StatusE:
  570|     23|      : reader_(reader),
  571|     23|        stream_bounds_({0, std::numeric_limits<size_t>::max()}),
  572|     23|        position_(0),
  573|     23|        current_field_(kInitialFieldKey),
  574|     23|        delimited_field_size_(0),
  575|     23|        delimited_field_offset_(0),
  576|     23|        parent_(parent),
  577|     23|        field_consumed_(true),
  578|     23|        nested_reader_open_(false),
  579|     23|        status_(status) {
  580|     23|    PW_ASSERT(!status.ok());
  ------------------
  |  |   31|     23|  do {                                            \
  |  |   32|     23|    if (!(condition)) {                           \
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 23]
  |  |  ------------------
  |  |   33|      0|      PW_ASSERT_failed_in_constant_expression_(); \
  |  |   34|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);       \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   35|      0|    }                                             \
  |  |   36|     23|  } while (0)
  |  |  ------------------
  |  |  |  Branch (36:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  581|     23|  }
_ZN2pw8protobuf13StreamDecoder14RemainingBytesEv:
  585|  36.9k|  size_t RemainingBytes() {
  586|  36.9k|    return stream_bounds_.high < std::numeric_limits<size_t>::max()
  ------------------
  |  Branch (586:12): [True: 18.4k, False: 18.4k]
  ------------------
  587|  36.9k|               ? stream_bounds_.high - position_
  588|  36.9k|               : std::numeric_limits<size_t>::max();
  589|  36.9k|  }

_ZN2pw8protobuf8FieldKey10IsValidKeyEm:
   56|  13.5k|  static constexpr bool IsValidKey(uint64_t key) {
   57|  13.5k|    uint64_t field_number = key >> kFieldNumberShift;
   58|  13.5k|    uint32_t wire_type = key & kWireTypeMask;
   59|       |
   60|  13.5k|    return ValidFieldNumber(field_number) && (wire_type <= 2 || wire_type == 5);
  ------------------
  |  Branch (60:12): [True: 13.4k, False: 112]
  |  Branch (60:47): [True: 12.3k, False: 1.09k]
  |  Branch (60:65): [True: 1.07k, False: 16]
  ------------------
   61|  13.5k|  }
_ZN2pw8protobuf8FieldKeyC2Ej:
   75|  13.3k|  constexpr FieldKey(uint32_t key) : key_(key) {
   76|  13.3k|    PW_DASSERT(ValidFieldNumber(field_number()));
  ------------------
  |  |   50|  13.3k|  do {                                                   \
  |  |   51|  13.3k|    if ((PW_ASSERT_ENABLE_DEBUG == 1) && !(condition)) { \
  |  |  ------------------
  |  |  |  |   26|  13.3k|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  ------------------
  |  |  |  Branch (51:9): [Folded - Ignored]
  |  |  |  Branch (51:42): [True: 0, False: 13.3k]
  |  |  ------------------
  |  |   52|      0|      PW_ASSERT_failed_in_constant_expression_();        \
  |  |   53|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);              \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   54|      0|    }                                                    \
  |  |   55|  13.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   77|  13.3k|  }
_ZNK2pw8protobuf8FieldKey12field_numberEv:
   81|  13.3k|  constexpr uint32_t field_number() const { return key_ >> kFieldNumberShift; }
_ZNK2pw8protobuf8FieldKey9wire_typeEv:
   82|  26.6k|  constexpr WireType wire_type() const {
   83|  26.6k|    return static_cast<WireType>(key_ & kWireTypeMask);
   84|  26.6k|  }
_ZN2pw8protobuf16ValidFieldNumberEj:
   30|  26.8k|constexpr bool ValidFieldNumber(uint32_t field_number) {
   31|  26.8k|  return field_number != 0 && field_number <= kMaxFieldNumber &&
  ------------------
  |  Branch (31:10): [True: 26.8k, False: 7]
  |  Branch (31:31): [True: 26.8k, False: 36]
  ------------------
   32|  26.8k|         !(field_number >= kFirstReservedNumber &&
  ------------------
  |  Branch (32:12): [True: 848, False: 25.9k]
  ------------------
   33|  26.8k|           field_number <= kLastReservedNumber);
  ------------------
  |  Branch (33:12): [True: 11, False: 837]
  ------------------
   34|  26.8k|}
_ZN2pw8protobuf16ValidFieldNumberEm:
   36|  13.5k|constexpr bool ValidFieldNumber(uint64_t field_number) {
   37|  13.5k|  if (field_number > std::numeric_limits<uint32_t>::max()) {
  ------------------
  |  Branch (37:7): [True: 58, False: 13.4k]
  ------------------
   38|     58|    return false;
   39|     58|  }
   40|  13.4k|  return ValidFieldNumber(static_cast<uint32_t>(field_number));
   41|  13.5k|}

_ZN2pw15internal_result12StatusOrDataIjLb1EEC2INS_6StatusETnNSt3__19enable_ifIXsr3std16is_constructibleIS4_OT_EE5valueEiE4typeELi0EEES8_:
  218|    155|      : status_(std::forward<U>(v)), unused_() {                               \
  219|    155|    PW_ASSERT(!status_.ok());                                                  \
  ------------------
  |  |   31|    155|  do {                                            \
  |  |   32|    155|    if (!(condition)) {                           \
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 155]
  |  |  ------------------
  |  |   33|      0|      PW_ASSERT_failed_in_constant_expression_(); \
  |  |   34|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);       \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   35|      0|    }                                             \
  |  |   36|    155|  } while (0)
  |  |  ------------------
  |  |  |  Branch (36:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  220|    155|  }                                                                            \
_ZN2pw15internal_result12StatusOrDataIjLb1EEC2IJjEEENSt3__110in_place_tEDpOT_:
  208|    586|      : status_(), data_(std::forward<Args>(args)...) {}                       \
_ZN2pw15internal_result12StatusOrDataImLb1EEC2INS_6StatusETnNSt3__19enable_ifIXsr3std16is_constructibleIS4_OT_EE5valueEiE4typeELi0EEES8_:
  218|     32|      : status_(std::forward<U>(v)), unused_() {                               \
  219|     32|    PW_ASSERT(!status_.ok());                                                  \
  ------------------
  |  |   31|     32|  do {                                            \
  |  |   32|     32|    if (!(condition)) {                           \
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 32]
  |  |  ------------------
  |  |   33|      0|      PW_ASSERT_failed_in_constant_expression_(); \
  |  |   34|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);       \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   35|      0|    }                                             \
  |  |   36|     32|  } while (0)
  |  |  ------------------
  |  |  |  Branch (36:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  220|     32|  }                                                                            \
_ZN2pw15internal_result12StatusOrDataImLb1EEC2IJmEEENSt3__110in_place_tEDpOT_:
  208|    403|      : status_(), data_(std::forward<Args>(args)...) {}                       \
_ZN2pw15internal_result12StatusOrDataIiLb1EEC2INS_6StatusETnNSt3__19enable_ifIXsr3std16is_constructibleIS4_OT_EE5valueEiE4typeELi0EEES8_:
  218|    365|      : status_(std::forward<U>(v)), unused_() {                               \
  219|    365|    PW_ASSERT(!status_.ok());                                                  \
  ------------------
  |  |   31|    365|  do {                                            \
  |  |   32|    365|    if (!(condition)) {                           \
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 365]
  |  |  ------------------
  |  |   33|      0|      PW_ASSERT_failed_in_constant_expression_(); \
  |  |   34|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);       \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   35|      0|    }                                             \
  |  |   36|    365|  } while (0)
  |  |  ------------------
  |  |  |  Branch (36:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  220|    365|  }                                                                            \
_ZN2pw15internal_result12StatusOrDataIiLb1EEC2IJiEEENSt3__110in_place_tEDpOT_:
  208|    951|      : status_(), data_(std::forward<Args>(args)...) {}                       \
_ZN2pw15internal_result12StatusOrDataIlLb1EEC2INS_6StatusETnNSt3__19enable_ifIXsr3std16is_constructibleIS4_OT_EE5valueEiE4typeELi0EEES8_:
  218|    116|      : status_(std::forward<U>(v)), unused_() {                               \
  219|    116|    PW_ASSERT(!status_.ok());                                                  \
  ------------------
  |  |   31|    116|  do {                                            \
  |  |   32|    116|    if (!(condition)) {                           \
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 116]
  |  |  ------------------
  |  |   33|      0|      PW_ASSERT_failed_in_constant_expression_(); \
  |  |   34|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);       \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   35|      0|    }                                             \
  |  |   36|    116|  } while (0)
  |  |  ------------------
  |  |  |  Branch (36:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  220|    116|  }                                                                            \
_ZN2pw15internal_result12StatusOrDataIlLb1EEC2IJlEEENSt3__110in_place_tEDpOT_:
  208|    612|      : status_(), data_(std::forward<Args>(args)...) {}                       \
_ZN2pw15internal_result12StatusOrDataIbLb1EEC2INS_6StatusETnNSt3__19enable_ifIXsr3std16is_constructibleIS4_OT_EE5valueEiE4typeELi0EEES8_:
  218|    169|      : status_(std::forward<U>(v)), unused_() {                               \
  219|    169|    PW_ASSERT(!status_.ok());                                                  \
  ------------------
  |  |   31|    169|  do {                                            \
  |  |   32|    169|    if (!(condition)) {                           \
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 169]
  |  |  ------------------
  |  |   33|      0|      PW_ASSERT_failed_in_constant_expression_(); \
  |  |   34|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);       \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   35|      0|    }                                             \
  |  |   36|    169|  } while (0)
  |  |  ------------------
  |  |  |  Branch (36:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  220|    169|  }                                                                            \
_ZN2pw15internal_result12StatusOrDataIbLb1EEC2IJbEEENSt3__110in_place_tEDpOT_:
  208|    196|      : status_(), data_(std::forward<Args>(args)...) {}                       \
_ZN2pw15internal_result12StatusOrDataIfLb1EEC2INS_6StatusETnNSt3__19enable_ifIXsr3std16is_constructibleIS4_OT_EE5valueEiE4typeELi0EEES8_:
  218|      8|      : status_(std::forward<U>(v)), unused_() {                               \
  219|      8|    PW_ASSERT(!status_.ok());                                                  \
  ------------------
  |  |   31|      8|  do {                                            \
  |  |   32|      8|    if (!(condition)) {                           \
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 8]
  |  |  ------------------
  |  |   33|      0|      PW_ASSERT_failed_in_constant_expression_(); \
  |  |   34|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);       \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   35|      0|    }                                             \
  |  |   36|      8|  } while (0)
  |  |  ------------------
  |  |  |  Branch (36:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  220|      8|  }                                                                            \
_ZN2pw15internal_result12StatusOrDataIfLb1EEC2IJfEEENSt3__110in_place_tEDpOT_:
  208|    293|      : status_(), data_(std::forward<Args>(args)...) {}                       \
_ZN2pw15internal_result12StatusOrDataIdLb1EEC2INS_6StatusETnNSt3__19enable_ifIXsr3std16is_constructibleIS4_OT_EE5valueEiE4typeELi0EEES8_:
  218|      7|      : status_(std::forward<U>(v)), unused_() {                               \
  219|      7|    PW_ASSERT(!status_.ok());                                                  \
  ------------------
  |  |   31|      7|  do {                                            \
  |  |   32|      7|    if (!(condition)) {                           \
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 7]
  |  |  ------------------
  |  |   33|      0|      PW_ASSERT_failed_in_constant_expression_(); \
  |  |   34|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);       \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   35|      0|    }                                             \
  |  |   36|      7|  } while (0)
  |  |  ------------------
  |  |  |  Branch (36:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  220|      7|  }                                                                            \
_ZN2pw15internal_result12StatusOrDataIdLb1EEC2IJdEEENSt3__110in_place_tEDpOT_:
  208|    204|      : status_(), data_(std::forward<Args>(args)...) {}                       \
_ZN2pw15internal_result12StatusOrDataINS_4spanISt4byteLm18446744073709551615EEELb1EEC2IJS4_EEENSt3__110in_place_tEDpOT_:
  208|  49.2k|      : status_(), data_(std::forward<Args>(args)...) {}                       \
_ZN2pw15internal_result12StatusOrDataINS_4spanISt4byteLm18446744073709551615EEELb1EEC2INS_6StatusETnNSt3__19enable_ifIXsr3std16is_constructibleIS7_OT_EE5valueEiE4typeELi0EEESB_:
  218|    448|      : status_(std::forward<U>(v)), unused_() {                               \
  219|    448|    PW_ASSERT(!status_.ok());                                                  \
  ------------------
  |  |   31|    448|  do {                                            \
  |  |   32|    448|    if (!(condition)) {                           \
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 448]
  |  |  ------------------
  |  |   33|      0|      PW_ASSERT_failed_in_constant_expression_(); \
  |  |   34|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);       \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   35|      0|    }                                             \
  |  |   36|    448|  } while (0)
  |  |  ------------------
  |  |  |  Branch (36:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  220|    448|  }                                                                            \

_ZN2pw6ResultIjEC2INS_6StatusETnNSt3__19enable_ifIXsr3std11conjunctionINS4_14is_convertibleIOT_S3_EENS4_16is_constructibleIS3_JS8_EEENS4_8negationINS4_7is_sameIu7__decayIS7_ES1_EEEENSC_INSD_ISE_jEEEENSC_INSD_ISE_NS4_10in_place_tEEEEENSC_INS_15internal_result29HasConversionOperatorToResultIjS8_vEEEEEE5valueEiE4typeELi0EEES8_:
  298|    155|  constexpr Result(U&& v) : Base(std::forward<U>(v)) {}
_ZN2pw6ResultIjEC2IjTnNSt3__19enable_ifIXsr3std11conjunctionINS3_11disjunctionIJNS3_7is_sameIju11__remove_cvIu20__remove_reference_tIOT_EEEENS3_8negationINS5_IJNS6_IS1_SA_EENS6_INS_6StatusESA_EENS6_INS3_10in_place_tESA_EENS_15internal_result31IsDirectInitializationAmbiguousIjS8_EEEEEEEEEENS3_16is_constructibleIjJS8_EEENS3_14is_convertibleIS8_jEENS5_IJNS6_Iu11__remove_cvIu20__remove_reference_tIS7_EEjEENS3_11conjunctionIJNSC_INSQ_IS8_SE_EEEENSC_INSI_29HasConversionOperatorToResultIjS8_vEEEEEEEEEEEE5valueEiE4typeELi0EEES8_:
  396|    586|      : Result(std::in_place, std::forward<U>(u)) {}
_ZN2pw6ResultIjEC2IJjEEENSt3__110in_place_tEDpOT_:
  770|    586|    : Base(std::in_place, std::forward<Args>(args)...) {}
_ZNO2pw6ResultIjE6statusEv:
  784|    741|constexpr Status Result<T>::status() && {
  785|    741|  return ok() ? OkStatus() : std::move(this->status_);
  ------------------
  |  Branch (785:10): [True: 586, False: 155]
  ------------------
  786|    741|}
_ZNK2pw6ResultIjE2okEv:
  430|    741|  [[nodiscard]] constexpr bool ok() const { return this->status_.ok(); }
_ZN2pw6ResultImEC2INS_6StatusETnNSt3__19enable_ifIXsr3std11conjunctionINS4_14is_convertibleIOT_S3_EENS4_16is_constructibleIS3_JS8_EEENS4_8negationINS4_7is_sameIu7__decayIS7_ES1_EEEENSC_INSD_ISE_mEEEENSC_INSD_ISE_NS4_10in_place_tEEEEENSC_INS_15internal_result29HasConversionOperatorToResultImS8_vEEEEEE5valueEiE4typeELi0EEES8_:
  298|     32|  constexpr Result(U&& v) : Base(std::forward<U>(v)) {}
_ZN2pw6ResultImEC2ImTnNSt3__19enable_ifIXsr3std11conjunctionINS3_11disjunctionIJNS3_7is_sameImu11__remove_cvIu20__remove_reference_tIOT_EEEENS3_8negationINS5_IJNS6_IS1_SA_EENS6_INS_6StatusESA_EENS6_INS3_10in_place_tESA_EENS_15internal_result31IsDirectInitializationAmbiguousImS8_EEEEEEEEEENS3_16is_constructibleImJS8_EEENS3_14is_convertibleIS8_mEENS5_IJNS6_Iu11__remove_cvIu20__remove_reference_tIS7_EEmEENS3_11conjunctionIJNSC_INSQ_IS8_SE_EEEENSC_INSI_29HasConversionOperatorToResultImS8_vEEEEEEEEEEEE5valueEiE4typeELi0EEES8_:
  396|    403|      : Result(std::in_place, std::forward<U>(u)) {}
_ZN2pw6ResultImEC2IJmEEENSt3__110in_place_tEDpOT_:
  770|    403|    : Base(std::in_place, std::forward<Args>(args)...) {}
_ZNO2pw6ResultImE6statusEv:
  784|    435|constexpr Status Result<T>::status() && {
  785|    435|  return ok() ? OkStatus() : std::move(this->status_);
  ------------------
  |  Branch (785:10): [True: 403, False: 32]
  ------------------
  786|    435|}
_ZNK2pw6ResultImE2okEv:
  430|    435|  [[nodiscard]] constexpr bool ok() const { return this->status_.ok(); }
_ZN2pw6ResultIiEC2INS_6StatusETnNSt3__19enable_ifIXsr3std11conjunctionINS4_14is_convertibleIOT_S3_EENS4_16is_constructibleIS3_JS8_EEENS4_8negationINS4_7is_sameIu7__decayIS7_ES1_EEEENSC_INSD_ISE_iEEEENSC_INSD_ISE_NS4_10in_place_tEEEEENSC_INS_15internal_result29HasConversionOperatorToResultIiS8_vEEEEEE5valueEiE4typeELi0EEES8_:
  298|    365|  constexpr Result(U&& v) : Base(std::forward<U>(v)) {}
_ZN2pw6ResultIiEC2IiTnNSt3__19enable_ifIXsr3std11conjunctionINS3_11disjunctionIJNS3_7is_sameIiu11__remove_cvIu20__remove_reference_tIOT_EEEENS3_8negationINS5_IJNS6_IS1_SA_EENS6_INS_6StatusESA_EENS6_INS3_10in_place_tESA_EENS_15internal_result31IsDirectInitializationAmbiguousIiS8_EEEEEEEEEENS3_16is_constructibleIiJS8_EEENS3_14is_convertibleIS8_iEENS5_IJNS6_Iu11__remove_cvIu20__remove_reference_tIS7_EEiEENS3_11conjunctionIJNSC_INSQ_IS8_SE_EEEENSC_INSI_29HasConversionOperatorToResultIiS8_vEEEEEEEEEEEE5valueEiE4typeELi0EEES8_:
  396|    951|      : Result(std::in_place, std::forward<U>(u)) {}
_ZN2pw6ResultIiEC2IJiEEENSt3__110in_place_tEDpOT_:
  770|    951|    : Base(std::in_place, std::forward<Args>(args)...) {}
_ZNO2pw6ResultIiE6statusEv:
  784|  1.31k|constexpr Status Result<T>::status() && {
  785|  1.31k|  return ok() ? OkStatus() : std::move(this->status_);
  ------------------
  |  Branch (785:10): [True: 951, False: 365]
  ------------------
  786|  1.31k|}
_ZNK2pw6ResultIiE2okEv:
  430|  1.31k|  [[nodiscard]] constexpr bool ok() const { return this->status_.ok(); }
_ZN2pw6ResultIlEC2INS_6StatusETnNSt3__19enable_ifIXsr3std11conjunctionINS4_14is_convertibleIOT_S3_EENS4_16is_constructibleIS3_JS8_EEENS4_8negationINS4_7is_sameIu7__decayIS7_ES1_EEEENSC_INSD_ISE_lEEEENSC_INSD_ISE_NS4_10in_place_tEEEEENSC_INS_15internal_result29HasConversionOperatorToResultIlS8_vEEEEEE5valueEiE4typeELi0EEES8_:
  298|    116|  constexpr Result(U&& v) : Base(std::forward<U>(v)) {}
_ZN2pw6ResultIlEC2IlTnNSt3__19enable_ifIXsr3std11conjunctionINS3_11disjunctionIJNS3_7is_sameIlu11__remove_cvIu20__remove_reference_tIOT_EEEENS3_8negationINS5_IJNS6_IS1_SA_EENS6_INS_6StatusESA_EENS6_INS3_10in_place_tESA_EENS_15internal_result31IsDirectInitializationAmbiguousIlS8_EEEEEEEEEENS3_16is_constructibleIlJS8_EEENS3_14is_convertibleIS8_lEENS5_IJNS6_Iu11__remove_cvIu20__remove_reference_tIS7_EElEENS3_11conjunctionIJNSC_INSQ_IS8_SE_EEEENSC_INSI_29HasConversionOperatorToResultIlS8_vEEEEEEEEEEEE5valueEiE4typeELi0EEES8_:
  396|    612|      : Result(std::in_place, std::forward<U>(u)) {}
_ZN2pw6ResultIlEC2IJlEEENSt3__110in_place_tEDpOT_:
  770|    612|    : Base(std::in_place, std::forward<Args>(args)...) {}
_ZNO2pw6ResultIlE6statusEv:
  784|    728|constexpr Status Result<T>::status() && {
  785|    728|  return ok() ? OkStatus() : std::move(this->status_);
  ------------------
  |  Branch (785:10): [True: 612, False: 116]
  ------------------
  786|    728|}
_ZNK2pw6ResultIlE2okEv:
  430|    728|  [[nodiscard]] constexpr bool ok() const { return this->status_.ok(); }
_ZN2pw6ResultIbEC2INS_6StatusETnNSt3__19enable_ifIXsr3std11conjunctionINS4_14is_convertibleIOT_S3_EENS4_16is_constructibleIS3_JS8_EEENS4_8negationINS4_7is_sameIu7__decayIS7_ES1_EEEENSC_INSD_ISE_bEEEENSC_INSD_ISE_NS4_10in_place_tEEEEENSC_INS_15internal_result29HasConversionOperatorToResultIbS8_vEEEEEE5valueEiE4typeELi0EEES8_:
  298|    169|  constexpr Result(U&& v) : Base(std::forward<U>(v)) {}
_ZN2pw6ResultIbEC2IbTnNSt3__19enable_ifIXsr3std11conjunctionINS3_11disjunctionIJNS3_7is_sameIbu11__remove_cvIu20__remove_reference_tIOT_EEEENS3_8negationINS5_IJNS6_IS1_SA_EENS6_INS_6StatusESA_EENS6_INS3_10in_place_tESA_EENS_15internal_result31IsDirectInitializationAmbiguousIbS8_EEEEEEEEEENS3_16is_constructibleIbJS8_EEENS3_14is_convertibleIS8_bEENS5_IJNS6_Iu11__remove_cvIu20__remove_reference_tIS7_EEbEENS3_11conjunctionIJNSC_INSQ_IS8_SE_EEEENSC_INSI_29HasConversionOperatorToResultIbS8_vEEEEEEEEEEEE5valueEiE4typeELi0EEES8_:
  396|    196|      : Result(std::in_place, std::forward<U>(u)) {}
_ZN2pw6ResultIbEC2IJbEEENSt3__110in_place_tEDpOT_:
  770|    196|    : Base(std::in_place, std::forward<Args>(args)...) {}
_ZNO2pw6ResultIbE6statusEv:
  784|    365|constexpr Status Result<T>::status() && {
  785|    365|  return ok() ? OkStatus() : std::move(this->status_);
  ------------------
  |  Branch (785:10): [True: 196, False: 169]
  ------------------
  786|    365|}
_ZNK2pw6ResultIbE2okEv:
  430|    365|  [[nodiscard]] constexpr bool ok() const { return this->status_.ok(); }
_ZN2pw6ResultIfEC2INS_6StatusETnNSt3__19enable_ifIXsr3std11conjunctionINS4_14is_convertibleIOT_S3_EENS4_16is_constructibleIS3_JS8_EEENS4_8negationINS4_7is_sameIu7__decayIS7_ES1_EEEENSC_INSD_ISE_fEEEENSC_INSD_ISE_NS4_10in_place_tEEEEENSC_INS_15internal_result29HasConversionOperatorToResultIfS8_vEEEEEE5valueEiE4typeELi0EEES8_:
  298|      8|  constexpr Result(U&& v) : Base(std::forward<U>(v)) {}
_ZN2pw6ResultIfEC2IfTnNSt3__19enable_ifIXsr3std11conjunctionINS3_11disjunctionIJNS3_7is_sameIfu11__remove_cvIu20__remove_reference_tIOT_EEEENS3_8negationINS5_IJNS6_IS1_SA_EENS6_INS_6StatusESA_EENS6_INS3_10in_place_tESA_EENS_15internal_result31IsDirectInitializationAmbiguousIfS8_EEEEEEEEEENS3_16is_constructibleIfJS8_EEENS3_14is_convertibleIS8_fEENS5_IJNS6_Iu11__remove_cvIu20__remove_reference_tIS7_EEfEENS3_11conjunctionIJNSC_INSQ_IS8_SE_EEEENSC_INSI_29HasConversionOperatorToResultIfS8_vEEEEEEEEEEEE5valueEiE4typeELi0EEES8_:
  396|    293|      : Result(std::in_place, std::forward<U>(u)) {}
_ZN2pw6ResultIfEC2IJfEEENSt3__110in_place_tEDpOT_:
  770|    293|    : Base(std::in_place, std::forward<Args>(args)...) {}
_ZNO2pw6ResultIfE6statusEv:
  784|    301|constexpr Status Result<T>::status() && {
  785|    301|  return ok() ? OkStatus() : std::move(this->status_);
  ------------------
  |  Branch (785:10): [True: 293, False: 8]
  ------------------
  786|    301|}
_ZNK2pw6ResultIfE2okEv:
  430|    301|  [[nodiscard]] constexpr bool ok() const { return this->status_.ok(); }
_ZN2pw6ResultIdEC2INS_6StatusETnNSt3__19enable_ifIXsr3std11conjunctionINS4_14is_convertibleIOT_S3_EENS4_16is_constructibleIS3_JS8_EEENS4_8negationINS4_7is_sameIu7__decayIS7_ES1_EEEENSC_INSD_ISE_dEEEENSC_INSD_ISE_NS4_10in_place_tEEEEENSC_INS_15internal_result29HasConversionOperatorToResultIdS8_vEEEEEE5valueEiE4typeELi0EEES8_:
  298|      7|  constexpr Result(U&& v) : Base(std::forward<U>(v)) {}
_ZN2pw6ResultIdEC2IdTnNSt3__19enable_ifIXsr3std11conjunctionINS3_11disjunctionIJNS3_7is_sameIdu11__remove_cvIu20__remove_reference_tIOT_EEEENS3_8negationINS5_IJNS6_IS1_SA_EENS6_INS_6StatusESA_EENS6_INS3_10in_place_tESA_EENS_15internal_result31IsDirectInitializationAmbiguousIdS8_EEEEEEEEEENS3_16is_constructibleIdJS8_EEENS3_14is_convertibleIS8_dEENS5_IJNS6_Iu11__remove_cvIu20__remove_reference_tIS7_EEdEENS3_11conjunctionIJNSC_INSQ_IS8_SE_EEEENSC_INSI_29HasConversionOperatorToResultIdS8_vEEEEEEEEEEEE5valueEiE4typeELi0EEES8_:
  396|    204|      : Result(std::in_place, std::forward<U>(u)) {}
_ZN2pw6ResultIdEC2IJdEEENSt3__110in_place_tEDpOT_:
  770|    204|    : Base(std::in_place, std::forward<Args>(args)...) {}
_ZNO2pw6ResultIdE6statusEv:
  784|    211|constexpr Status Result<T>::status() && {
  785|    211|  return ok() ? OkStatus() : std::move(this->status_);
  ------------------
  |  Branch (785:10): [True: 204, False: 7]
  ------------------
  786|    211|}
_ZNK2pw6ResultIdE2okEv:
  430|    211|  [[nodiscard]] constexpr bool ok() const { return this->status_.ok(); }
_ZNK2pw6ResultINS_4spanISt4byteLm18446744073709551615EEEE2okEv:
  430|  49.7k|  [[nodiscard]] constexpr bool ok() const { return this->status_.ok(); }
_ZNKR2pw6ResultINS_4spanISt4byteLm18446744073709551615EEEE6statusEv:
  780|    448|constexpr const Status& Result<T>::status() const& {
  781|    448|  return this->status_;
  782|    448|}
_ZN2pw6ResultINS_4spanISt4byteLm18446744073709551615EEEEC2IS3_TnNSt3__19enable_ifIXsr3std11conjunctionINS6_11disjunctionIJNS6_7is_sameIS3_u11__remove_cvIu20__remove_reference_tIOT_EEEENS6_8negationINS8_IJNS9_IS4_SD_EENS9_INS_6StatusESD_EENS9_INS6_10in_place_tESD_EENS_15internal_result31IsDirectInitializationAmbiguousIS3_SB_EEEEEEEEEENS6_16is_constructibleIS3_JSB_EEENS6_14is_convertibleISB_S3_EENS8_IJNS9_Iu11__remove_cvIu20__remove_reference_tISA_EES3_EENS6_11conjunctionIJNSF_INST_ISB_SH_EEEENSF_INSL_29HasConversionOperatorToResultIS3_SB_vEEEEEEEEEEEE5valueEiE4typeELi0EEESB_:
  396|  49.2k|      : Result(std::in_place, std::forward<U>(u)) {}
_ZN2pw6ResultINS_4spanISt4byteLm18446744073709551615EEEEC2IJS3_EEENSt3__110in_place_tEDpOT_:
  770|  49.2k|    : Base(std::in_place, std::forward<Args>(args)...) {}
_ZN2pw6ResultINS_4spanISt4byteLm18446744073709551615EEEEC2INS_6StatusETnNSt3__19enable_ifIXsr3std11conjunctionINS7_14is_convertibleIOT_S6_EENS7_16is_constructibleIS6_JSB_EEENS7_8negationINS7_7is_sameIu7__decayISA_ES4_EEEENSF_INSG_ISH_S3_EEEENSF_INSG_ISH_NS7_10in_place_tEEEEENSF_INS_15internal_result29HasConversionOperatorToResultIS3_SB_vEEEEEE5valueEiE4typeELi0EEESB_:
  298|    448|  constexpr Result(U&& v) : Base(std::forward<U>(v)) {}
_ZNR2pw6ResultINS_4spanISt4byteLm18446744073709551615EEEE5valueEv:
  795|  6.18k|constexpr T& Result<T>::value() & {
  796|  6.18k|  PW_ASSERT(this->status_.ok());
  ------------------
  |  |   31|  6.18k|  do {                                            \
  |  |   32|  6.18k|    if (!(condition)) {                           \
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 6.18k]
  |  |  ------------------
  |  |   33|      0|      PW_ASSERT_failed_in_constant_expression_(); \
  |  |   34|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);       \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   35|      0|    }                                             \
  |  |   36|  6.18k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (36:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  797|  6.18k|  return this->data_;
  798|  6.18k|}

_ZN2pw4spanIKSt4byteLm18446744073709551615EEC2INSt3__16vectorIS1_NS5_9allocatorIS1_EEEEvEERT_:
  297|  2.32k|      : span(std::data(container), std::size(container)) {}
_ZN2pw4spanIKSt4byteLm18446744073709551615EEC2EPS2_m:
  255|  2.32k|      : ExtentStorage(size), data_(data) {
  256|  2.32k|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|  2.32k|  }
_ZN2pw16pw_span_internal13ExtentStorageILm18446744073709551615EEC2Em:
  153|   139k|  constexpr explicit ExtentStorage(size_t size) noexcept : size_(size) {}
_ZN2pw17as_writable_bytesImLm18446744073709551615EvEENS_4spanISt4byteXqueqT0_L_ZNS_14dynamic_extentEEL_ZNS_14dynamic_extentEEmlstT_T0_EEENS1_IS3_XT0_EEE:
  433|  2.40k|as_writable_bytes(span<T, X> s) noexcept {
  434|  2.40k|  return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  435|  2.40k|}
_ZNK2pw4spanImLm18446744073709551615EE4dataEv:
  400|  2.40k|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanImLm18446744073709551615EE10size_bytesEv:
  376|  2.40k|  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
_ZNK2pw4spanImLm18446744073709551615EE4sizeEv:
  375|  2.40k|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZNK2pw16pw_span_internal13ExtentStorageILm18446744073709551615EE4sizeEv:
  154|   292k|  constexpr size_t size() const noexcept { return size_; }
_ZN2pw4spanISt4byteLm18446744073709551615EEC2EPS1_m:
  255|   127k|      : ExtentStorage(size), data_(data) {
  256|   127k|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|   127k|  }
_ZN2pw4spanImLm18446744073709551615EEC2EPmm:
  255|  2.40k|      : ExtentStorage(size), data_(data) {
  256|  2.40k|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|  2.40k|  }
_ZN2pw17as_writable_bytesIjLm18446744073709551615EvEENS_4spanISt4byteXqueqT0_L_ZNS_14dynamic_extentEEL_ZNS_14dynamic_extentEEmlstT_T0_EEENS1_IS3_XT0_EEE:
  433|  1.02k|as_writable_bytes(span<T, X> s) noexcept {
  434|  1.02k|  return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  435|  1.02k|}
_ZNK2pw4spanIjLm18446744073709551615EE4dataEv:
  400|  1.02k|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanIjLm18446744073709551615EE10size_bytesEv:
  376|  1.02k|  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
_ZNK2pw4spanIjLm18446744073709551615EE4sizeEv:
  375|  1.02k|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZN2pw4spanIjLm18446744073709551615EEC2ILm256EvEERAT__j:
  273|    714|  constexpr span(T (&array)[N]) noexcept : span(std::data(array), N) {}
_ZN2pw4spanIjLm18446744073709551615EEC2EPjm:
  255|  1.02k|      : ExtentStorage(size), data_(data) {
  256|  1.02k|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|  1.02k|  }
_ZN2pw4spanImLm18446744073709551615EEC2ILm256EvEERAT__m:
  273|  1.17k|  constexpr span(T (&array)[N]) noexcept : span(std::data(array), N) {}
_ZN2pw17as_writable_bytesIlLm18446744073709551615EvEENS_4spanISt4byteXqueqT0_L_ZNS_14dynamic_extentEEL_ZNS_14dynamic_extentEEmlstT_T0_EEENS1_IS3_XT0_EEE:
  433|  2.64k|as_writable_bytes(span<T, X> s) noexcept {
  434|  2.64k|  return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  435|  2.64k|}
_ZNK2pw4spanIlLm18446744073709551615EE4dataEv:
  400|  2.64k|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanIlLm18446744073709551615EE10size_bytesEv:
  376|  2.64k|  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
_ZNK2pw4spanIlLm18446744073709551615EE4sizeEv:
  375|  2.64k|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZN2pw4spanIlLm18446744073709551615EEC2EPlm:
  255|  2.64k|      : ExtentStorage(size), data_(data) {
  256|  2.64k|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|  2.64k|  }
_ZN2pw17as_writable_bytesIiLm18446744073709551615EvEENS_4spanISt4byteXqueqT0_L_ZNS_14dynamic_extentEEL_ZNS_14dynamic_extentEEmlstT_T0_EEENS1_IS3_XT0_EEE:
  433|  1.55k|as_writable_bytes(span<T, X> s) noexcept {
  434|  1.55k|  return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  435|  1.55k|}
_ZNK2pw4spanIiLm18446744073709551615EE4dataEv:
  400|  1.55k|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanIiLm18446744073709551615EE10size_bytesEv:
  376|  1.55k|  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
_ZNK2pw4spanIiLm18446744073709551615EE4sizeEv:
  375|  1.55k|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZN2pw4spanIiLm18446744073709551615EEC2ILm256EvEERAT__i:
  273|  1.14k|  constexpr span(T (&array)[N]) noexcept : span(std::data(array), N) {}
_ZN2pw4spanIiLm18446744073709551615EEC2EPim:
  255|  1.55k|      : ExtentStorage(size), data_(data) {
  256|  1.55k|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|  1.55k|  }
_ZN2pw4spanIlLm18446744073709551615EEC2ILm256EvEERAT__l:
  273|  1.00k|  constexpr span(T (&array)[N]) noexcept : span(std::data(array), N) {}
_ZN2pw17as_writable_bytesIfLm18446744073709551615EvEENS_4spanISt4byteXqueqT0_L_ZNS_14dynamic_extentEEL_ZNS_14dynamic_extentEEmlstT_T0_EEENS1_IS3_XT0_EEE:
  433|    672|as_writable_bytes(span<T, X> s) noexcept {
  434|    672|  return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  435|    672|}
_ZNK2pw4spanIfLm18446744073709551615EE4dataEv:
  400|    672|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanIfLm18446744073709551615EE10size_bytesEv:
  376|    672|  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
_ZNK2pw4spanIfLm18446744073709551615EE4sizeEv:
  375|    672|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZN2pw4spanIfLm18446744073709551615EEC2EPfm:
  255|    672|      : ExtentStorage(size), data_(data) {
  256|    672|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|    672|  }
_ZN2pw4spanIfLm18446744073709551615EEC2ILm256EvEERAT__f:
  273|    371|  constexpr span(T (&array)[N]) noexcept : span(std::data(array), N) {}
_ZN2pw17as_writable_bytesIdLm18446744073709551615EvEENS_4spanISt4byteXqueqT0_L_ZNS_14dynamic_extentEEL_ZNS_14dynamic_extentEEmlstT_T0_EEENS1_IS3_XT0_EEE:
  433|    561|as_writable_bytes(span<T, X> s) noexcept {
  434|    561|  return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  435|    561|}
_ZNK2pw4spanIdLm18446744073709551615EE4dataEv:
  400|    561|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanIdLm18446744073709551615EE10size_bytesEv:
  376|    561|  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
_ZNK2pw4spanIdLm18446744073709551615EE4sizeEv:
  375|    561|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZN2pw4spanIdLm18446744073709551615EEC2EPdm:
  255|    561|      : ExtentStorage(size), data_(data) {
  256|    561|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|    561|  }
_ZN2pw4spanIdLm18446744073709551615EEC2ILm256EvEERAT__d:
  273|    350|  constexpr span(T (&array)[N]) noexcept : span(std::data(array), N) {}
_ZN2pw4spanISt4byteLm18446744073709551615EEC2ILm256EvEERAT__S1_:
  273|    772|  constexpr span(T (&array)[N]) noexcept : span(std::data(array), N) {}
_ZN2pw17as_writable_bytesIcLm18446744073709551615EvEENS_4spanISt4byteXqueqT0_L_ZNS_14dynamic_extentEEL_ZNS_14dynamic_extentEEmlstT_T0_EEENS1_IS3_XT0_EEE:
  433|    420|as_writable_bytes(span<T, X> s) noexcept {
  434|    420|  return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  435|    420|}
_ZNK2pw4spanIcLm18446744073709551615EE4dataEv:
  400|    420|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanIcLm18446744073709551615EE10size_bytesEv:
  376|    420|  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
_ZNK2pw4spanIcLm18446744073709551615EE4sizeEv:
  375|    420|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZN2pw4spanIcLm18446744073709551615EEC2ILm256EvEERAT__c:
  273|    420|  constexpr span(T (&array)[N]) noexcept : span(std::data(array), N) {}
_ZN2pw4spanIcLm18446744073709551615EEC2EPcm:
  255|    420|      : ExtentStorage(size), data_(data) {
  256|    420|    _PW_SPAN_ASSERT(Extent == dynamic_extent || Extent == size);
  257|    420|  }
_ZNK2pw4spanISt4byteLm18446744073709551615EE4sizeEv:
  375|   169k|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZNK2pw4spanISt4byteLm18446744073709551615EE5emptyEv:
  377|  59.9k|  [[nodiscard]] constexpr bool empty() const noexcept { return size() == 0; }
_ZNK2pw4spanISt4byteLm18446744073709551615EE4dataEv:
  400|   178k|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanISt4byteLm18446744073709551615EE5firstEm:
  354|  62.7k|  constexpr span<T, dynamic_extent> first(size_t count) const noexcept {
  355|       |    // Note: CHECK_LE is not constexpr, hence regular CHECK must be used.
  356|  62.7k|    _PW_SPAN_ASSERT(count <= size());
  357|  62.7k|    return {data(), count};
  358|  62.7k|  }
_ZNK2pw4spanISt4byteLm18446744073709551615EE7subspanEmm:
  367|  9.76k|      size_t offset, size_t count = dynamic_extent) const noexcept {
  368|       |    // Note: CHECK_LE is not constexpr, hence regular CHECK must be used.
  369|  9.76k|    _PW_SPAN_ASSERT(offset <= size());
  370|  9.76k|    _PW_SPAN_ASSERT(count == dynamic_extent || count <= size() - offset);
  371|  9.76k|    return {data() + offset, count != dynamic_extent ? count : size() - offset};
  ------------------
  |  Branch (371:30): [True: 0, False: 9.76k]
  ------------------
  372|  9.76k|  }
_ZNK2pw4spanIKSt4byteLm18446744073709551615EE4sizeEv:
  375|   112k|  constexpr size_t size() const noexcept { return ExtentStorage::size(); }
_ZNK2pw4spanIKSt4byteLm18446744073709551615EE4dataEv:
  400|  46.7k|  constexpr T* data() const noexcept { return data_; }
_ZNK2pw4spanISt4byteLm18446744073709551615EE10size_bytesEv:
  376|  49.2k|  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
_ZNK2pw4spanIKSt4byteLm18446744073709551615EE10size_bytesEv:
  376|   109k|  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }

_ZN2pw6StatusC2E9pw_Status:
  146|   124k|  constexpr Status(Code code = PW_STATUS_OK) : code_(code) {}
_ZN2pw8OkStatusEv:
  234|  31.9k|[[nodiscard]] constexpr Status OkStatus() { return Status(); }
_ZNK2pw6Status2okEv:
  157|   128k|  [[nodiscard]] constexpr bool ok() const { return code_ == PW_STATUS_OK; }
_ZN2pw6Status18FailedPreconditionEv:
  119|    664|  [[nodiscard]] static constexpr Status FailedPrecondition() {
  120|    664|    return PW_STATUS_FAILED_PRECONDITION;
  121|    664|  }
_ZN2pw6Status8NotFoundEv:
  107|    194|  [[nodiscard]] static constexpr Status NotFound() {
  108|    194|    return PW_STATUS_NOT_FOUND;
  109|    194|  }
_ZN2pw6Status17ResourceExhaustedEv:
  116|    104|  [[nodiscard]] static constexpr Status ResourceExhausted() {
  117|    104|    return PW_STATUS_RESOURCE_EXHAUSTED;
  118|    104|  }
_ZN2pw6Status10OutOfRangeEv:
  125|  2.04k|  [[nodiscard]] static constexpr Status OutOfRange() {
  126|  2.04k|    return PW_STATUS_OUT_OF_RANGE;
  127|  2.04k|  }
_ZN2pw6Status8DataLossEv:
  137|  3.25k|  [[nodiscard]] static constexpr Status DataLoss() {
  138|  3.25k|    return PW_STATUS_DATA_LOSS;
  139|  3.25k|  }
_ZNK2pw6Status4codeEv:
  152|  8.94k|  constexpr Code code() const { return code_; }
_ZNK2pw6Status12IsOutOfRangeEv:
  190|  21.8k|  [[nodiscard]] constexpr bool IsOutOfRange() const {
  191|  21.8k|    return code_ == PW_STATUS_OUT_OF_RANGE;
  192|  21.8k|  }
_ZN2pw6Status6UpdateES0_:
  213|      5|  constexpr void Update(Status other) {
  214|      5|    if (ok()) {
  ------------------
  |  Branch (214:9): [True: 3, False: 2]
  ------------------
  215|      3|      code_ = other.code();
  216|      3|    }
  217|      5|  }
_ZN2pwneERKNS_6StatusES2_:
  240|  2.39k|constexpr bool operator!=(const Status& lhs, const Status& rhs) {
  241|  2.39k|  return lhs.code() != rhs.code();
  242|  2.39k|}
_ZN2pw8internal15ConvertToStatusENS_6StatusE:
  248|    119|constexpr Status ConvertToStatus(Status status) { return status; }

_ZNK2pw14StatusWithSize6statusEv:
  161|  33.4k|  [[nodiscard]] constexpr Status status() const {
  162|  33.4k|    return static_cast<Status::Code>((size_ & kStatusMask) >> kStatusShift);
  163|  33.4k|  }
_ZN2pw14StatusWithSize17ResourceExhaustedEm:
   75|     93|  static constexpr StatusWithSize ResourceExhausted(size_t size = 0) {
   76|     93|    return StatusWithSize(Status::ResourceExhausted(), size);
   77|     93|  }
_ZN2pw14StatusWithSize10OutOfRangeEm:
   84|    454|  static constexpr StatusWithSize OutOfRange(size_t size = 0) {
   85|    454|    return StatusWithSize(Status::OutOfRange(), size);
   86|    454|  }
_ZN2pw14StatusWithSize8DataLossEm:
   96|    446|  static constexpr StatusWithSize DataLoss(size_t size = 0) {
   97|    446|    return StatusWithSize(Status::DataLoss(), size);
   98|    446|  }
_ZN2pw14StatusWithSizeC2ENS_6StatusEm:
  113|  4.14k|      : StatusWithSize((static_cast<size_t>(status.code()) << kStatusShift) |
  114|  4.14k|                       size) {}
_ZNK2pw14StatusWithSize4sizeEv:
  146|  94.5k|  [[nodiscard]] constexpr size_t size() const { return size_ & kSizeMask; }
_ZNK2pw14StatusWithSize2okEv:
  152|  95.1k|  [[nodiscard]] constexpr bool ok() const {
  153|  95.1k|    return (size_ & kStatusMask) == 0u;
  154|  95.1k|  }
_ZNK2pw14StatusWithSize12IsOutOfRangeEv:
  196|  21.7k|  [[nodiscard]] constexpr bool IsOutOfRange() const {
  197|  21.7k|    return status().IsOutOfRange();
  198|  21.7k|  }
_ZN2pw8internal15ConvertToStatusENS_14StatusWithSizeE:
  226|    103|constexpr Status ConvertToStatus(StatusWithSize status_with_size) {
  227|    103|  return status_with_size.status();
  228|    103|}
_ZN2pw8internal14ConvertToValueENS_14StatusWithSizeE:
  230|  13.5k|constexpr size_t ConvertToValue(StatusWithSize status_with_size) {
  231|  13.5k|  return status_with_size.size();
  232|  13.5k|}
_ZN2pw14StatusWithSizeC2ImvEET_:
  107|  88.7k|  explicit constexpr StatusWithSize(T size) : size_(static_cast<size_t>(size)) {
  108|       |    // TODO(hepler): Add debug-only assert that size <= max_size().
  109|  88.7k|  }
_ZN2pw14StatusWithSizeC2IivEET_:
  107|  2.57k|  explicit constexpr StatusWithSize(T size) : size_(static_cast<size_t>(size)) {
  108|       |    // TODO(hepler): Add debug-only assert that size <= max_size().
  109|  2.57k|  }

_ZN2pw6stream12MemoryReaderC2ENS_4spanIKSt4byteLm18446744073709551615EEE:
  113|  2.32k|      : source_(source), position_(0) {}
_ZNK2pw6stream12MemoryReader17ConservativeLimitENS0_6Stream9LimitTypeE:
  120|  10.7k|  size_t ConservativeLimit(LimitType type) const override {
  121|  10.7k|    return type == LimitType::kRead ? source_.size_bytes() - position_ : 0;
  ------------------
  |  Branch (121:12): [True: 10.7k, False: 0]
  ------------------
  122|  10.7k|  }
_ZN2pw6stream12MemoryReader6DoSeekElNS0_6Stream6WhenceE:
  124|  3.16k|  Status DoSeek(ptrdiff_t offset, Whence origin) override {
  125|  3.16k|    return CalculateSeek(offset, origin, source_.size(), position_);
  126|  3.16k|  }

_ZN2pw6stream17ResolveSeekOffsetElNS0_6Stream6WhenceEmm:
   28|  3.16k|                                      size_t current_position) {
   29|  3.16k|  switch (origin) {
   30|      0|    case Stream::kBeginning:
  ------------------
  |  Branch (30:5): [True: 0, False: 3.16k]
  ------------------
   31|      0|      return offset;
   32|  3.16k|    case Stream::kCurrent:
  ------------------
  |  Branch (32:5): [True: 3.16k, False: 0]
  ------------------
   33|  3.16k|      return static_cast<ptrdiff_t>(current_position) + offset;
   34|      0|    case Stream::kEnd:
  ------------------
  |  Branch (34:5): [True: 0, False: 3.16k]
  ------------------
   35|      0|    default:
  ------------------
  |  Branch (35:5): [True: 0, False: 3.16k]
  ------------------
   36|      0|      return static_cast<ptrdiff_t>(end_position) + offset;
   37|  3.16k|  }
   38|  3.16k|}
_ZN2pw6stream13CalculateSeekElNS0_6Stream6WhenceEmRm:
   47|  3.16k|                               size_t& current_position) {
   48|  3.16k|  const ptrdiff_t new_position =
   49|  3.16k|      ResolveSeekOffset(offset, origin, end_position, current_position);
   50|       |
   51|  3.16k|  if (new_position < 0 || static_cast<size_t>(new_position) > end_position) {
  ------------------
  |  Branch (51:7): [True: 0, False: 3.16k]
  |  Branch (51:27): [True: 0, False: 3.16k]
  ------------------
   52|      0|    return Status::OutOfRange();
   53|      0|  }
   54|       |
   55|  3.16k|  current_position = static_cast<size_t>(new_position);
   56|  3.16k|  return OkStatus();
   57|  3.16k|}

_ZN2pw6stream14SeekableReaderC2Ev:
  396|  2.32k|  constexpr SeekableReader() : RelativeSeekableReader(Seekability::kAbsolute) {}
_ZN2pw6stream22RelativeSeekableReaderC2ENS0_6Stream11SeekabilityE:
  382|  2.32k|      : Reader(seekability) {}
_ZN2pw6stream6ReaderC2ENS0_6Stream11SeekabilityE:
  351|  2.32k|      : Stream(true, false, seekability) {}
_ZN2pw6stream6StreamC2EbbNS1_11SeekabilityE:
  299|  2.32k|      : readable_(readable), writable_(writable), seekability_(seekability) {}
_ZN2pw6stream6StreamD2Ev:
   69|  2.32k|  virtual ~Stream() = default;
_ZNK2pw6stream6Stream8seekableEv:
   81|  3.16k|  constexpr bool seekable() const { return seekability_ != Seekability::kNone; }
_ZN2pw6stream6Stream4ReadENS_4spanISt4byteLm18446744073709551615EEE:
  120|  49.7k|  Result<ByteSpan> Read(ByteSpan dest) {
  121|  49.7k|    PW_DASSERT(dest.empty() || dest.data() != nullptr);
  ------------------
  |  |   50|  49.7k|  do {                                                   \
  |  |   51|  96.7k|    if ((PW_ASSERT_ENABLE_DEBUG == 1) && !(condition)) { \
  |  |  ------------------
  |  |  |  |   26|  49.7k|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  ------------------
  |  |  |  Branch (51:9): [Folded - Ignored]
  |  |  |  Branch (51:44): [True: 2.78k, False: 46.9k]
  |  |  |  Branch (51:44): [True: 46.9k, False: 0]
  |  |  ------------------
  |  |   52|      0|      PW_ASSERT_failed_in_constant_expression_();        \
  |  |   53|      0|      PW_ASSERT_HANDLE_FAILURE(#condition);              \
  |  |  ------------------
  |  |  |  |   54|      0|  PW_ASSERT_PRINT_EXPRESSION("ASSERT", expression); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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__
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   55|      0|  fflush(stderr);                                   \
  |  |  |  |   56|      0|  abort()
  |  |  ------------------
  |  |   54|      0|    }                                                    \
  |  |   55|  49.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  122|  49.7k|    StatusWithSize result = DoRead(dest);
  123|       |
  124|  49.7k|    if (result.ok()) {
  ------------------
  |  Branch (124:9): [True: 49.2k, False: 448]
  ------------------
  125|  49.2k|      return dest.first(result.size());
  126|  49.2k|    }
  127|    448|    return result.status();
  128|  49.7k|  }
_ZN2pw6stream6Stream4SeekElNS1_6WhenceE:
  220|  3.16k|  Status Seek(ptrdiff_t offset, Whence origin = kBeginning) {
  221|  3.16k|    return DoSeek(offset, origin);
  222|  3.16k|  }
_ZNK2pw6stream6Stream21ConservativeReadLimitEv:
  240|  10.7k|  size_t ConservativeReadLimit() const {
  241|  10.7k|    return ConservativeLimit(LimitType::kRead);
  242|  10.7k|  }

_ZN2pw6varint12ZigZagDecodeImEEu13__make_signedIT_ES2_:
  215|  3.05k|    PW_NO_SANITIZE("unsigned-integer-overflow") {
  216|  3.05k|  static_assert(std::is_unsigned<T>(),
  217|  3.05k|                "Zig-zag decoding is for unsigned integers");
  218|  3.05k|  return static_cast<std::make_signed_t<T>>((n >> 1) ^ (~(n & 1) + 1));
  219|  3.05k|}

LLVMFuzzerTestOneInput:
  219|  2.32k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  220|  2.32k|  FuzzedDataProvider provider(data, size);
  221|  2.32k|  pw::protobuf::fuzz::TestOneInput(provider);
  222|  2.32k|  return 0;
  223|  2.32k|}
decoder_fuzzer.cc:_ZN2pw8protobuf4fuzz12_GLOBAL__N_112TestOneInputER18FuzzedDataProvider:
  207|  2.32k|void TestOneInput(FuzzedDataProvider& provider) {
  208|  2.32k|  constexpr size_t kMaxFuzzedProtoSize = 4096;
  209|  2.32k|  std::vector<std::byte> proto_message_data = provider.ConsumeBytes<std::byte>(
  210|  2.32k|      provider.ConsumeIntegralInRange<size_t>(0, kMaxFuzzedProtoSize));
  211|  2.32k|  stream::MemoryReader memory_reader(proto_message_data);
  212|  2.32k|  StreamDecoder decoder(memory_reader);
  213|  2.32k|  RecursiveFuzzedDecode(provider, decoder);
  214|  2.32k|}
decoder_fuzzer.cc:_ZN2pw8protobuf4fuzz12_GLOBAL__N_121RecursiveFuzzedDecodeER18FuzzedDataProviderRNS0_13StreamDecoderEj:
   35|  5.57k|                           uint32_t depth = 0) {
   36|  5.57k|  constexpr size_t kMaxRepeatedRead = 256;
   37|  5.57k|  constexpr size_t kMaxDepth = 3;
   38|       |
   39|  5.57k|  if (depth > kMaxDepth) {
  ------------------
  |  Branch (39:7): [True: 795, False: 4.77k]
  ------------------
   40|    795|    return;
   41|    795|  }
   42|  16.3k|  while (provider.remaining_bytes() != 0 && decoder.Next().ok()) {
  ------------------
  |  Branch (42:10): [True: 15.2k, False: 1.08k]
  |  Branch (42:10): [True: 13.3k, False: 3.03k]
  |  Branch (42:45): [True: 13.3k, False: 1.95k]
  ------------------
   43|  13.3k|    FieldType field_type = provider.ConsumeEnum<FieldType>();
   44|  13.3k|    switch (field_type) {
  ------------------
  |  Branch (44:13): [True: 0, False: 13.3k]
  ------------------
   45|    429|      case kUint32:
  ------------------
  |  Branch (45:7): [True: 429, False: 12.8k]
  ------------------
   46|    429|        if (!decoder.ReadUint32().status().ok()) {
  ------------------
  |  Branch (46:13): [True: 146, False: 283]
  ------------------
   47|    146|          return;
   48|    146|        }
   49|    283|        break;
   50|    414|      case kPackedUint32: {
  ------------------
  |  Branch (50:7): [True: 414, False: 12.8k]
  ------------------
   51|    414|        uint32_t packed[kMaxRepeatedRead] = {0};
   52|    414|        if (!decoder.ReadPackedUint32(packed).status().ok()) {
  ------------------
  |  Branch (52:13): [True: 125, False: 289]
  ------------------
   53|    125|          return;
   54|    125|        }
   55|    414|      } break;
   56|    289|      case kUint64:
  ------------------
  |  Branch (56:7): [True: 225, False: 13.0k]
  ------------------
   57|    225|        if (!decoder.ReadUint64().status().ok()) {
  ------------------
  |  Branch (57:13): [True: 22, False: 203]
  ------------------
   58|     22|          return;
   59|     22|        }
   60|    203|        break;
   61|    535|      case kPackedUint64: {
  ------------------
  |  Branch (61:7): [True: 535, False: 12.7k]
  ------------------
   62|    535|        uint64_t packed[kMaxRepeatedRead] = {0};
   63|    535|        if (!decoder.ReadPackedUint64(packed).status().ok()) {
  ------------------
  |  Branch (63:13): [True: 79, False: 456]
  ------------------
   64|     79|          return;
   65|     79|        }
   66|    535|      } break;
   67|    470|      case kInt32:
  ------------------
  |  Branch (67:7): [True: 470, False: 12.8k]
  ------------------
   68|    470|        if (!decoder.ReadInt32().status().ok()) {
  ------------------
  |  Branch (68:13): [True: 212, False: 258]
  ------------------
   69|    212|          return;
   70|    212|        }
   71|    258|        break;
   72|    319|      case kPackedInt32: {
  ------------------
  |  Branch (72:7): [True: 319, False: 12.9k]
  ------------------
   73|    319|        int32_t packed[kMaxRepeatedRead] = {0};
   74|    319|        if (!decoder.ReadPackedInt32(packed).status().ok()) {
  ------------------
  |  Branch (74:13): [True: 46, False: 273]
  ------------------
   75|     46|          return;
   76|     46|        }
   77|    319|      } break;
   78|    273|      case kInt64:
  ------------------
  |  Branch (78:7): [True: 225, False: 13.0k]
  ------------------
   79|    225|        if (!decoder.ReadInt64().status().ok()) {
  ------------------
  |  Branch (79:13): [True: 28, False: 197]
  ------------------
   80|     28|          return;
   81|     28|        }
   82|    197|        break;
   83|    344|      case kPackedInt64: {
  ------------------
  |  Branch (83:7): [True: 344, False: 12.9k]
  ------------------
   84|    344|        int64_t packed[kMaxRepeatedRead] = {0};
   85|    344|        if (!decoder.ReadPackedInt64(packed).status().ok()) {
  ------------------
  |  Branch (85:13): [True: 55, False: 289]
  ------------------
   86|     55|          return;
   87|     55|        }
   88|    344|      } break;
   89|    442|      case kSint32:
  ------------------
  |  Branch (89:7): [True: 442, False: 12.8k]
  ------------------
   90|    442|        if (!decoder.ReadSint32().status().ok()) {
  ------------------
  |  Branch (90:13): [True: 144, False: 298]
  ------------------
   91|    144|          return;
   92|    144|        }
   93|    298|        break;
   94|    509|      case kPackedSint32: {
  ------------------
  |  Branch (94:7): [True: 509, False: 12.7k]
  ------------------
   95|    509|        int32_t packed[kMaxRepeatedRead] = {0};
   96|    509|        if (!decoder.ReadPackedSint32(packed).status().ok()) {
  ------------------
  |  Branch (96:13): [True: 132, False: 377]
  ------------------
   97|    132|          return;
   98|    132|        }
   99|    509|      } break;
  100|    377|      case kSint64:
  ------------------
  |  Branch (100:7): [True: 293, False: 13.0k]
  ------------------
  101|    293|        if (!decoder.ReadSint64().status().ok()) {
  ------------------
  |  Branch (101:13): [True: 77, False: 216]
  ------------------
  102|     77|          return;
  103|     77|        }
  104|    216|        break;
  105|    335|      case kPackedSint64: {
  ------------------
  |  Branch (105:7): [True: 335, False: 12.9k]
  ------------------
  106|    335|        int64_t packed[kMaxRepeatedRead] = {0};
  107|    335|        if (!decoder.ReadPackedSint64(packed).status().ok()) {
  ------------------
  |  Branch (107:13): [True: 46, False: 289]
  ------------------
  108|     46|          return;
  109|     46|        }
  110|    335|      } break;
  111|    365|      case kBool:
  ------------------
  |  Branch (111:7): [True: 365, False: 12.9k]
  ------------------
  112|    365|        if (!decoder.ReadBool().status().ok()) {
  ------------------
  |  Branch (112:13): [True: 169, False: 196]
  ------------------
  113|    169|          return;
  114|    169|        }
  115|    196|        break;
  116|    312|      case kFixed32:
  ------------------
  |  Branch (116:7): [True: 312, False: 12.9k]
  ------------------
  117|    312|        if (!decoder.ReadFixed32().status().ok()) {
  ------------------
  |  Branch (117:13): [True: 9, False: 303]
  ------------------
  118|      9|          return;
  119|      9|        }
  120|    303|        break;
  121|    303|      case kPackedFixed32: {
  ------------------
  |  Branch (121:7): [True: 300, False: 13.0k]
  ------------------
  122|    300|        uint32_t packed[kMaxRepeatedRead] = {0};
  123|    300|        if (!decoder.ReadPackedFixed32(packed).status().ok()) {
  ------------------
  |  Branch (123:13): [True: 39, False: 261]
  ------------------
  124|     39|          return;
  125|     39|        }
  126|    300|      } break;
  127|    261|      case kFixed64:
  ------------------
  |  Branch (127:7): [True: 210, False: 13.0k]
  ------------------
  128|    210|        if (!decoder.ReadFixed64().status().ok()) {
  ------------------
  |  Branch (128:13): [True: 10, False: 200]
  ------------------
  129|     10|          return;
  130|     10|        }
  131|    200|        break;
  132|    639|      case kPackedFixed64: {
  ------------------
  |  Branch (132:7): [True: 639, False: 12.6k]
  ------------------
  133|    639|        uint64_t packed[kMaxRepeatedRead] = {0};
  134|    639|        if (!decoder.ReadPackedFixed64(packed).status().ok()) {
  ------------------
  |  Branch (134:13): [True: 44, False: 595]
  ------------------
  135|     44|          return;
  136|     44|        }
  137|    639|      } break;
  138|    595|      case kSfixed32:
  ------------------
  |  Branch (138:7): [True: 404, False: 12.8k]
  ------------------
  139|    404|        if (!decoder.ReadSfixed32().status().ok()) {
  ------------------
  |  Branch (139:13): [True: 9, False: 395]
  ------------------
  140|      9|          return;
  141|      9|        }
  142|    395|        break;
  143|    395|      case kPackedSfixed32: {
  ------------------
  |  Branch (143:7): [True: 320, False: 12.9k]
  ------------------
  144|    320|        int32_t packed[kMaxRepeatedRead] = {0};
  145|    320|        if (!decoder.ReadPackedSfixed32(packed).status().ok()) {
  ------------------
  |  Branch (145:13): [True: 41, False: 279]
  ------------------
  146|     41|          return;
  147|     41|        }
  148|    320|      } break;
  149|    279|      case kSfixed64:
  ------------------
  |  Branch (149:7): [True: 210, False: 13.0k]
  ------------------
  150|    210|        if (!decoder.ReadSfixed64().status().ok()) {
  ------------------
  |  Branch (150:13): [True: 11, False: 199]
  ------------------
  151|     11|          return;
  152|     11|        }
  153|    199|        break;
  154|    326|      case kPackedSfixed64: {
  ------------------
  |  Branch (154:7): [True: 326, False: 12.9k]
  ------------------
  155|    326|        int64_t packed[kMaxRepeatedRead] = {0};
  156|    326|        if (!decoder.ReadPackedSfixed64(packed).status().ok()) {
  ------------------
  |  Branch (156:13): [True: 41, False: 285]
  ------------------
  157|     41|          return;
  158|     41|        }
  159|    326|      } break;
  160|    301|      case kFloat:
  ------------------
  |  Branch (160:7): [True: 301, False: 13.0k]
  ------------------
  161|    301|        if (!decoder.ReadFloat().status().ok()) {
  ------------------
  |  Branch (161:13): [True: 8, False: 293]
  ------------------
  162|      8|          return;
  163|      8|        }
  164|    293|        break;
  165|    371|      case kPackedFloat: {
  ------------------
  |  Branch (165:7): [True: 371, False: 12.9k]
  ------------------
  166|    371|        float packed[kMaxRepeatedRead] = {0};
  167|    371|        if (!decoder.ReadPackedFloat(packed).status().ok()) {
  ------------------
  |  Branch (167:13): [True: 47, False: 324]
  ------------------
  168|     47|          return;
  169|     47|        }
  170|    371|      } break;
  171|    324|      case kDouble:
  ------------------
  |  Branch (171:7): [True: 211, False: 13.0k]
  ------------------
  172|    211|        if (!decoder.ReadDouble().status().ok()) {
  ------------------
  |  Branch (172:13): [True: 7, False: 204]
  ------------------
  173|      7|          return;
  174|      7|        }
  175|    204|        break;
  176|    350|      case kPackedDouble: {
  ------------------
  |  Branch (176:7): [True: 350, False: 12.9k]
  ------------------
  177|    350|        double packed[kMaxRepeatedRead] = {0};
  178|    350|        if (!decoder.ReadPackedDouble(packed).status().ok()) {
  ------------------
  |  Branch (178:13): [True: 61, False: 289]
  ------------------
  179|     61|          return;
  180|     61|        }
  181|    350|      } break;
  182|    772|      case kBytes: {
  ------------------
  |  Branch (182:7): [True: 772, False: 12.5k]
  ------------------
  183|    772|        std::byte bytes[kMaxRepeatedRead] = {std::byte{0}};
  184|    772|        if (!decoder.ReadBytes(bytes).status().ok()) {
  ------------------
  |  Branch (184:13): [True: 69, False: 703]
  ------------------
  185|     69|          return;
  186|     69|        }
  187|    772|      } break;
  188|    703|      case kString: {
  ------------------
  |  Branch (188:7): [True: 420, False: 12.8k]
  ------------------
  189|    420|        char str[kMaxRepeatedRead] = {0};
  190|    420|        if (!decoder.ReadString(str).status().ok()) {
  ------------------
  |  Branch (190:13): [True: 66, False: 354]
  ------------------
  191|     66|          return;
  192|     66|        }
  193|    420|      } break;
  194|  3.25k|      case kPush: {
  ------------------
  |  Branch (194:7): [True: 3.25k, False: 10.0k]
  ------------------
  195|  3.25k|        StreamDecoder nested_decoder = decoder.GetNestedDecoder();
  196|  3.25k|        RecursiveFuzzedDecode(provider, nested_decoder, depth + 1);
  197|  3.25k|      } break;
  198|      0|      case kPop:
  ------------------
  |  Branch (198:7): [True: 0, False: 13.3k]
  ------------------
  199|      0|        if (depth > 0) {
  ------------------
  |  Branch (199:13): [True: 0, False: 0]
  ------------------
  200|       |          // Special "field". The marks the end of a nested message.
  201|      0|          return;
  202|      0|        }
  203|  13.3k|    }
  204|  13.3k|  }
  205|  4.77k|}

_ZN2pw8protobuf13StreamDecoderD2Ev:
  105|  5.57k|StreamDecoder::~StreamDecoder() {
  106|  5.57k|  if (parent_ != nullptr) {
  ------------------
  |  Branch (106:7): [True: 3.25k, False: 2.32k]
  ------------------
  107|  3.25k|    parent_->CloseNestedDecoder(*this);
  108|  3.25k|  } else if (stream_bounds_.high < std::numeric_limits<size_t>::max()) {
  ------------------
  |  Branch (108:14): [True: 0, False: 2.32k]
  ------------------
  109|      0|    if (status_.ok()) {
  ------------------
  |  Branch (109:9): [True: 0, False: 0]
  ------------------
  110|       |      // Advance the stream to the end of the bounds.
  111|      0|      PW_CHECK(Advance(stream_bounds_.high).ok());
  ------------------
  |  |   39|      0|  do {                                                                         \
  |  |   40|      0|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, 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|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  112|      0|    }
  113|      0|  }
  114|  5.57k|}
_ZN2pw8protobuf13StreamDecoder4NextEv:
  116|  15.2k|Status StreamDecoder::Next() {
  117|  15.2k|  PW_CHECK(!nested_reader_open_,
  ------------------
  |  |   39|  15.2k|  do {                                                                         \
  |  |   40|  15.2k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 15.2k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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|  15.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  118|  15.2k|           "Cannot use parent decoder while a nested one is open");
  119|       |
  120|  15.2k|  PW_TRY(status_);
  ------------------
  |  |   25|  15.2k|#define PW_TRY(expr) _PW_TRY(_PW_TRY_UNIQUE(__LINE__), expr, return)
  |  |  ------------------
  |  |  |  |   28|  15.2k|  do {                                                     \
  |  |  |  |   29|  15.2k|    if (auto result = (expr); !result.ok()) {              \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (29:31): [True: 39, False: 15.2k]
  |  |  |  |  ------------------
  |  |  |  |   30|     39|      return_stmt ::pw::internal::ConvertToStatus(result); \
  |  |  |  |   31|     39|    }                                                      \
  |  |  |  |   32|  15.2k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (32:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  121|       |
  122|  15.2k|  if (!field_consumed_) {
  ------------------
  |  Branch (122:7): [True: 0, False: 15.2k]
  ------------------
  123|      0|    PW_TRY(SkipField());
  ------------------
  |  |   25|      0|#define PW_TRY(expr) _PW_TRY(_PW_TRY_UNIQUE(__LINE__), expr, return)
  |  |  ------------------
  |  |  |  |   28|      0|  do {                                                     \
  |  |  |  |   29|      0|    if (auto result = (expr); !result.ok()) {              \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (29:31): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   30|      0|      return_stmt ::pw::internal::ConvertToStatus(result); \
  |  |  |  |   31|      0|    }                                                      \
  |  |  |  |   32|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (32:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  124|      0|  }
  125|       |
  126|  15.2k|  if (position_ >= stream_bounds_.high) {
  ------------------
  |  Branch (126:7): [True: 1.59k, False: 13.6k]
  ------------------
  127|  1.59k|    return Status::OutOfRange();
  128|  1.59k|  }
  129|       |
  130|  13.6k|  status_ = ReadFieldKey();
  131|  13.6k|  return status_;
  132|  15.2k|}
_ZN2pw8protobuf13StreamDecoder16GetNestedDecoderEv:
  153|  3.25k|StreamDecoder StreamDecoder::GetNestedDecoder() {
  154|  3.25k|  Status status = CheckOkToRead(WireType::kDelimited);
  155|       |
  156|  3.25k|  if (reader_.ConservativeReadLimit() < delimited_field_size_) {
  ------------------
  |  Branch (156:7): [True: 5, False: 3.24k]
  ------------------
  157|      5|    status.Update(Status::DataLoss());
  158|      5|  }
  159|       |
  160|  3.25k|  nested_reader_open_ = true;
  161|       |
  162|  3.25k|  if (!status.ok()) {
  ------------------
  |  Branch (162:7): [True: 23, False: 3.22k]
  ------------------
  163|     23|    return StreamDecoder(reader_, this, status);
  164|     23|  }
  165|       |
  166|  3.22k|  size_t low = position_;
  167|  3.22k|  size_t high = low + delimited_field_size_;
  168|       |
  169|  3.22k|  return StreamDecoder(reader_, this, low, high);
  170|  3.25k|}
_ZN2pw8protobuf13StreamDecoder7AdvanceEm:
  172|  3.16k|Status StreamDecoder::Advance(size_t end_position) {
  173|  3.16k|  if (reader_.seekable()) {
  ------------------
  |  Branch (173:7): [True: 3.16k, False: 0]
  ------------------
  174|  3.16k|    PW_TRY(reader_.Seek(end_position - position_, stream::Stream::kCurrent));
  ------------------
  |  |   25|  3.16k|#define PW_TRY(expr) _PW_TRY(_PW_TRY_UNIQUE(__LINE__), expr, return)
  |  |  ------------------
  |  |  |  |   28|  3.16k|  do {                                                     \
  |  |  |  |   29|  3.16k|    if (auto result = (expr); !result.ok()) {              \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (29:31): [True: 0, False: 3.16k]
  |  |  |  |  ------------------
  |  |  |  |   30|      0|      return_stmt ::pw::internal::ConvertToStatus(result); \
  |  |  |  |   31|      0|    }                                                      \
  |  |  |  |   32|  3.16k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (32:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  175|  3.16k|    position_ = end_position;
  176|  3.16k|    return OkStatus();
  177|  3.16k|  }
  178|       |
  179|      0|  while (position_ < end_position) {
  ------------------
  |  Branch (179:10): [True: 0, False: 0]
  ------------------
  180|      0|    std::byte b;
  181|      0|    PW_TRY(reader_.Read(span(&b, 1)));
  ------------------
  |  |   25|      0|#define PW_TRY(expr) _PW_TRY(_PW_TRY_UNIQUE(__LINE__), expr, return)
  |  |  ------------------
  |  |  |  |   28|      0|  do {                                                     \
  |  |  |  |   29|      0|    if (auto result = (expr); !result.ok()) {              \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (29:31): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   30|      0|      return_stmt ::pw::internal::ConvertToStatus(result); \
  |  |  |  |   31|      0|    }                                                      \
  |  |  |  |   32|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (32:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  182|      0|    position_++;
  183|      0|  }
  184|      0|  return OkStatus();
  185|      0|}
_ZN2pw8protobuf13StreamDecoder18CloseNestedDecoderERS1_:
  199|  3.25k|void StreamDecoder::CloseNestedDecoder(StreamDecoder& nested) {
  200|  3.25k|  PW_CHECK_PTR_EQ(nested.parent_, this);
  ------------------
  |  |  103|  3.25k|#define PW_CHECK_PTR_EQ(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, ==, argb, const void*, "%p", __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  229|  3.25k|  do {                                                                \
  |  |  |  |  230|  3.25k|    _PW_CHECK_CONVERT(type_decl, evaluated_argument_a, arg_a);        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  216|  3.25k|  type name = ::pw::assert::internal::ConvertToType<type>(arg)
  |  |  |  |  ------------------
  |  |  |  |  231|  3.25k|    _PW_CHECK_CONVERT(type_decl, evaluated_argument_b, arg_b);        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  216|  3.25k|  type name = ::pw::assert::internal::ConvertToType<type>(arg)
  |  |  |  |  ------------------
  |  |  |  |  232|  3.25k|    if (!(evaluated_argument_a comparison_op evaluated_argument_b)) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (232:9): [True: 0, False: 3.25k]
  |  |  |  |  ------------------
  |  |  |  |  233|      0|      _PW_CHECK_BINARY_ARG_HANDLER(#arg_a,                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|  _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |  |  |  |  |  256|      0|      arg_a_str arg_b_str); /* cannot use '%' in PW_CHECK conditions */    \
  |  |  |  |  |  |  257|      0|  if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (257:7): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  258|      0|    _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |  |  |  |  |  259|      0|  }                                                                        \
  |  |  |  |  |  |  260|      0|  PW_HANDLE_ASSERT_BINARY_COMPARE_FAILURE(arg_a_str,                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   37|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK",                                        \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   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__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   38|      0|                             arg_a_str " " comparison_op_str " " arg_b_str); \
  |  |  |  |  |  |  |  |   39|      0|  fprintf(stderr,                                                            \
  |  |  |  |  |  |  |  |   40|      0|          "  \033[33mEVALUATED CONDITION\033[0m\n\n    " arg_a_str           \
  |  |  |  |  |  |  |  |   41|      0|          " (=" type_fmt ") " comparison_op_str " " arg_b_str " (=" type_fmt \
  |  |  |  |  |  |  |  |   42|      0|          ")"                                                                \
  |  |  |  |  |  |  |  |   43|      0|          ".\n\n",                                                           \
  |  |  |  |  |  |  |  |   44|      0|          arg_a_val,                                                         \
  |  |  |  |  |  |  |  |   45|      0|          arg_b_val);                                                        \
  |  |  |  |  |  |  |  |   46|      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()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  261|      0|                                          arg_a_val,                       \
  |  |  |  |  |  |  262|      0|                                          comparison_op_str,               \
  |  |  |  |  |  |  263|      0|                                          arg_b_str,                       \
  |  |  |  |  |  |  264|      0|                                          arg_b_val,                       \
  |  |  |  |  |  |  265|      0|                                          type_fmt,                        \
  |  |  |  |  |  |  266|      0|                                          __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  234|      0|                                   evaluated_argument_a,              \
  |  |  |  |  235|      0|                                   #comparison_op,                    \
  |  |  |  |  236|      0|                                   #arg_b,                            \
  |  |  |  |  237|      0|                                   evaluated_argument_b,              \
  |  |  |  |  238|      0|                                   type_fmt,                          \
  |  |  |  |  239|      0|                                   "" __VA_ARGS__);                   \
  |  |  |  |  240|      0|    }                                                                 \
  |  |  |  |  241|  3.25k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (241:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  201|       |
  202|  3.25k|  nested.nested_reader_open_ = true;
  203|  3.25k|  nested.parent_ = nullptr;
  204|       |
  205|  3.25k|  status_ = nested.status_;
  206|  3.25k|  position_ = nested.position_;
  207|  3.25k|  if (status_.ok()) {
  ------------------
  |  Branch (207:7): [True: 3.16k, False: 83]
  ------------------
  208|       |    // Advance the stream to the end of the nested message field.
  209|  3.16k|    PW_CHECK(Advance(nested.stream_bounds_.high).ok());
  ------------------
  |  |   39|  3.16k|  do {                                                                         \
  |  |   40|  3.16k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 3.16k]
  |  |  ------------------
  |  |   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.16k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  210|  3.16k|  }
  211|       |
  212|  3.25k|  field_consumed_ = true;
  213|  3.25k|  nested_reader_open_ = false;
  214|  3.25k|}
_ZN2pw8protobuf13StreamDecoder12ReadFieldKeyEv:
  216|  13.6k|Status StreamDecoder::ReadFieldKey() {
  217|  13.6k|  PW_DCHECK(field_consumed_);
  ------------------
  |  |   51|  13.6k|  do {                            \
  |  |   52|  13.6k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|  13.6k|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|  13.6k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  13.6k|  do {                                                                         \
  |  |  |  |   40|  13.6k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 13.6k]
  |  |  |  |  ------------------
  |  |  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |  |  |   45|      0|      }                                                                        \
  |  |  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   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|  13.6k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  13.6k|    }                             \
  |  |   55|  13.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  218|       |
  219|  13.6k|  uint64_t varint = 0;
  220|  13.6k|  PW_TRY_ASSIGN(size_t bytes_read,
  ------------------
  |  |   37|  13.6k|  _PW_TRY_ASSIGN(_PW_TRY_UNIQUE(__LINE__), lhs, expression, return)
  |  |  ------------------
  |  |  |  |   40|  13.6k|  auto result = (expr);                                  \
  |  |  |  |   41|  13.6k|  if (!result.ok()) {                                    \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (41:7): [True: 103, False: 13.5k]
  |  |  |  |  ------------------
  |  |  |  |   42|    103|    return_stmt ::pw::internal::ConvertToStatus(result); \
  |  |  |  |   43|    103|  }                                                      \
  |  |  |  |   44|  13.6k|  lhs = ::pw::internal::ConvertToValue(result)
  |  |  ------------------
  ------------------
  221|  13.5k|                varint::Read(reader_, &varint, RemainingBytes()));
  222|  13.5k|  position_ += bytes_read;
  223|       |
  224|  13.5k|  if (!FieldKey::IsValidKey(varint)) {
  ------------------
  |  Branch (224:7): [True: 128, False: 13.3k]
  ------------------
  225|    128|    return Status::DataLoss();
  226|    128|  }
  227|       |
  228|  13.3k|  PW_DCHECK(varint <= std::numeric_limits<uint32_t>::max());
  ------------------
  |  |   51|  13.3k|  do {                            \
  |  |   52|  13.3k|    if (PW_ASSERT_ENABLE_DEBUG) { \
  |  |  ------------------
  |  |  |  |   26|  13.3k|#define PW_ASSERT_ENABLE_DEBUG 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (26:32): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|  13.3k|      PW_CHECK(__VA_ARGS__);      \
  |  |  ------------------
  |  |  |  |   39|  13.3k|  do {                                                                         \
  |  |  |  |   40|  13.3k|    if (!(condition)) {                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:9): [True: 0, False: 13.3k]
  |  |  |  |  ------------------
  |  |  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |  |  |   45|      0|      }                                                                        \
  |  |  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   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|  13.3k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  13.3k|    }                             \
  |  |   55|  13.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (55:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  229|  13.3k|  current_field_ = FieldKey(static_cast<uint32_t>(varint));
  230|       |
  231|  13.3k|  if (current_field_.wire_type() == WireType::kDelimited) {
  ------------------
  |  Branch (231:7): [True: 9.19k, False: 4.19k]
  ------------------
  232|       |    // Read the length varint of length-delimited fields immediately to simplify
  233|       |    // later processing of the field.
  234|  9.19k|    StatusWithSize sws = varint::Read(reader_, &varint, RemainingBytes());
  235|  9.19k|    position_ += sws.size();
  236|  9.19k|    if (sws.IsOutOfRange()) {
  ------------------
  |  Branch (236:9): [True: 24, False: 9.17k]
  ------------------
  237|       |      // Out of range indicates the end of the stream. As a value is expected
  238|       |      // here, report it as a data loss and terminate the decode operation.
  239|     24|      return Status::DataLoss();
  240|     24|    }
  241|  9.17k|    if (!sws.ok()) {
  ------------------
  |  Branch (241:9): [True: 3, False: 9.17k]
  ------------------
  242|      3|      return sws.status();
  243|      3|    }
  244|       |
  245|  9.17k|    if (varint > std::numeric_limits<uint32_t>::max()) {
  ------------------
  |  Branch (245:9): [True: 65, False: 9.10k]
  ------------------
  246|     65|      return Status::DataLoss();
  247|     65|    }
  248|       |
  249|  9.10k|    delimited_field_size_ = varint;
  250|  9.10k|    delimited_field_offset_ = position_;
  251|  9.10k|  }
  252|       |
  253|  13.3k|  field_consumed_ = false;
  254|  13.3k|  return OkStatus();
  255|  13.3k|}
_ZN2pw8protobuf13StreamDecoder15ReadVarintFieldENS_4spanISt4byteLm18446744073709551615EEENS0_8internal10VarintTypeE:
  314|  2.44k|                                      VarintType decode_type) {
  315|  2.44k|  PW_CHECK(out.size() == sizeof(bool) || out.size() == sizeof(uint32_t) ||
  ------------------
  |  |   39|  2.44k|  do {                                                                         \
  |  |   40|  9.79k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:11): [True: 0, False: 2.44k]
  |  |  |  Branch (40:11): [True: 0, False: 2.44k]
  |  |  |  Branch (40:11): [True: 2.44k, 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|  2.44k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  316|  2.44k|               out.size() == sizeof(uint64_t),
  317|  2.44k|           "Protobuf varints must only be used with bool, int32_t, uint32_t, "
  318|  2.44k|           "int64_t, or uint64_t");
  319|  2.44k|  PW_TRY(CheckOkToRead(WireType::kVarint));
  ------------------
  |  |   25|  2.44k|#define PW_TRY(expr) _PW_TRY(_PW_TRY_UNIQUE(__LINE__), expr, return)
  |  |  ------------------
  |  |  |  |   28|  2.44k|  do {                                                     \
  |  |  |  |   29|  2.44k|    if (auto result = (expr); !result.ok()) {              \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (29:31): [True: 50, False: 2.39k]
  |  |  |  |  ------------------
  |  |  |  |   30|     50|      return_stmt ::pw::internal::ConvertToStatus(result); \
  |  |  |  |   31|     50|    }                                                      \
  |  |  |  |   32|  2.44k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (32:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  320|       |
  321|  2.39k|  const StatusWithSize sws = ReadOneVarint(out, decode_type);
  322|  2.39k|  if (sws.status() != Status::DataLoss())
  ------------------
  |  Branch (322:7): [True: 2.12k, False: 276]
  ------------------
  323|  2.12k|    field_consumed_ = true;
  324|  2.39k|  return sws.status();
  325|  2.44k|}
_ZN2pw8protobuf13StreamDecoder13ReadOneVarintENS_4spanISt4byteLm18446744073709551615EEENS0_8internal10VarintTypeE:
  328|  12.5k|                                            VarintType decode_type) {
  329|  12.5k|  uint64_t value;
  330|  12.5k|  StatusWithSize sws = varint::Read(reader_, &value, RemainingBytes());
  331|  12.5k|  position_ += sws.size();
  332|  12.5k|  if (sws.IsOutOfRange()) {
  ------------------
  |  Branch (332:7): [True: 49, False: 12.4k]
  ------------------
  333|       |    // Out of range indicates the end of the stream. As a value is expected
  334|       |    // here, report it as a data loss and terminate the decode operation.
  335|     49|    status_ = Status::DataLoss();
  336|     49|    return StatusWithSize(status_, sws.size());
  337|     49|  }
  338|  12.4k|  if (!sws.ok()) {
  ------------------
  |  Branch (338:7): [True: 412, False: 12.0k]
  ------------------
  339|    412|    return sws;
  340|    412|  }
  341|       |
  342|  12.0k|  if (out.size() == sizeof(uint64_t)) {
  ------------------
  |  Branch (342:7): [True: 8.45k, False: 3.63k]
  ------------------
  343|  8.45k|    if (decode_type == VarintType::kUnsigned) {
  ------------------
  |  Branch (343:9): [True: 3.63k, False: 4.81k]
  ------------------
  344|  3.63k|      std::memcpy(out.data(), &value, out.size());
  345|  4.81k|    } else {
  346|  4.81k|      const int64_t signed_value = decode_type == VarintType::kZigZag
  ------------------
  |  Branch (346:36): [True: 1.73k, False: 3.07k]
  ------------------
  347|  4.81k|                                       ? varint::ZigZagDecode(value)
  348|  4.81k|                                       : static_cast<int64_t>(value);
  349|  4.81k|      std::memcpy(out.data(), &signed_value, out.size());
  350|  4.81k|    }
  351|  8.45k|  } else if (out.size() == sizeof(uint32_t)) {
  ------------------
  |  Branch (351:14): [True: 3.63k, False: 0]
  ------------------
  352|  3.63k|    if (decode_type == VarintType::kUnsigned) {
  ------------------
  |  Branch (352:9): [True: 1.44k, False: 2.18k]
  ------------------
  353|  1.44k|      if (value > std::numeric_limits<uint32_t>::max()) {
  ------------------
  |  Branch (353:11): [True: 86, False: 1.36k]
  ------------------
  354|     86|        return StatusWithSize(Status::FailedPrecondition(), sws.size());
  355|     86|      }
  356|  1.36k|      std::memcpy(out.data(), &value, out.size());
  357|  2.18k|    } else {
  358|  2.18k|      const int64_t signed_value = decode_type == VarintType::kZigZag
  ------------------
  |  Branch (358:36): [True: 1.31k, False: 862]
  ------------------
  359|  2.18k|                                       ? varint::ZigZagDecode(value)
  360|  2.18k|                                       : static_cast<int64_t>(value);
  361|  2.18k|      if (signed_value > std::numeric_limits<int32_t>::max() ||
  ------------------
  |  Branch (361:11): [True: 18, False: 2.16k]
  ------------------
  362|  2.18k|          signed_value < std::numeric_limits<int32_t>::min()) {
  ------------------
  |  Branch (362:11): [True: 88, False: 2.07k]
  ------------------
  363|    106|        return StatusWithSize(Status::FailedPrecondition(), sws.size());
  364|    106|      }
  365|  2.07k|      std::memcpy(out.data(), &signed_value, out.size());
  366|  2.07k|    }
  367|  3.63k|  } else if (out.size() == sizeof(bool)) {
  ------------------
  |  Branch (367:14): [True: 0, False: 0]
  ------------------
  368|      0|    PW_CHECK(decode_type == VarintType::kUnsigned,
  ------------------
  |  |   39|      0|  do {                                                                         \
  |  |   40|      0|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, 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|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  369|      0|             "Protobuf bool can never be signed");
  370|      0|    std::memcpy(out.data(), &value, out.size());
  371|      0|  }
  372|       |
  373|  11.8k|  return sws;
  374|  12.0k|}
_ZN2pw8protobuf13StreamDecoder14ReadFixedFieldENS_4spanISt4byteLm18446744073709551615EEE:
  376|  1.64k|Status StreamDecoder::ReadFixedField(span<std::byte> out) {
  377|  1.64k|  WireType expected_wire_type =
  378|  1.64k|      out.size() == sizeof(uint32_t) ? WireType::kFixed32 : WireType::kFixed64;
  ------------------
  |  Branch (378:7): [True: 1.01k, False: 631]
  ------------------
  379|  1.64k|  PW_TRY(CheckOkToRead(expected_wire_type));
  ------------------
  |  |   25|  1.64k|#define PW_TRY(expr) _PW_TRY(_PW_TRY_UNIQUE(__LINE__), expr, return)
  |  |  ------------------
  |  |  |  |   28|  1.64k|  do {                                                     \
  |  |  |  |   29|  1.64k|    if (auto result = (expr); !result.ok()) {              \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (29:31): [True: 30, False: 1.61k]
  |  |  |  |  ------------------
  |  |  |  |   30|     30|      return_stmt ::pw::internal::ConvertToStatus(result); \
  |  |  |  |   31|     30|    }                                                      \
  |  |  |  |   32|  1.64k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (32:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  380|       |
  381|  1.61k|  if (reader_.ConservativeReadLimit() < out.size()) {
  ------------------
  |  Branch (381:7): [True: 16, False: 1.60k]
  ------------------
  382|     16|    status_ = Status::DataLoss();
  383|     16|    return status_;
  384|     16|  }
  385|       |
  386|  1.60k|  if (RemainingBytes() < out.size()) {
  ------------------
  |  Branch (386:7): [True: 8, False: 1.59k]
  ------------------
  387|      8|    status_ = Status::DataLoss();
  388|      8|    return status_;
  389|      8|  }
  390|       |
  391|  1.59k|  PW_TRY(reader_.Read(out));
  ------------------
  |  |   25|  1.59k|#define PW_TRY(expr) _PW_TRY(_PW_TRY_UNIQUE(__LINE__), expr, return)
  |  |  ------------------
  |  |  |  |   28|  1.59k|  do {                                                     \
  |  |  |  |   29|  1.59k|    if (auto result = (expr); !result.ok()) {              \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (29:31): [True: 0, False: 1.59k]
  |  |  |  |  ------------------
  |  |  |  |   30|      0|      return_stmt ::pw::internal::ConvertToStatus(result); \
  |  |  |  |   31|      0|    }                                                      \
  |  |  |  |   32|  1.59k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (32:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  392|  1.59k|  position_ += out.size();
  393|  1.59k|  field_consumed_ = true;
  394|       |
  395|  1.59k|  if (endian::native != endian::little) {
  ------------------
  |  Branch (395:7): [Folded - Ignored]
  ------------------
  396|      0|    std::reverse(out.begin(), out.end());
  397|      0|  }
  398|       |
  399|  1.59k|  return OkStatus();
  400|  1.59k|}
_ZN2pw8protobuf13StreamDecoder18ReadDelimitedFieldENS_4spanISt4byteLm18446744073709551615EEE:
  402|  1.19k|StatusWithSize StreamDecoder::ReadDelimitedField(span<std::byte> out) {
  403|  1.19k|  if (Status status = CheckOkToRead(WireType::kDelimited); !status.ok()) {
  ------------------
  |  Branch (403:60): [True: 12, False: 1.18k]
  ------------------
  404|     12|    return StatusWithSize(status, 0);
  405|     12|  }
  406|       |
  407|  1.18k|  if (reader_.ConservativeReadLimit() < delimited_field_size_) {
  ------------------
  |  Branch (407:7): [True: 36, False: 1.14k]
  ------------------
  408|     36|    status_ = Status::DataLoss();
  409|     36|    return StatusWithSize(status_, 0);
  410|     36|  }
  411|       |
  412|  1.14k|  if (out.size() < delimited_field_size_) {
  ------------------
  |  Branch (412:7): [True: 32, False: 1.11k]
  ------------------
  413|       |    // Value can't fit into the provided buffer. Don't advance the cursor so
  414|       |    // that the field can be re-read with a larger buffer or through the stream
  415|       |    // API.
  416|     32|    return StatusWithSize::ResourceExhausted();
  417|     32|  }
  418|       |
  419|  1.11k|  Result<ByteSpan> result = reader_.Read(out.first(delimited_field_size_));
  420|  1.11k|  if (!result.ok()) {
  ------------------
  |  Branch (420:7): [True: 55, False: 1.05k]
  ------------------
  421|     55|    return StatusWithSize(result.status(), 0);
  422|     55|  }
  423|       |
  424|  1.05k|  position_ += result.value().size();
  425|  1.05k|  field_consumed_ = true;
  426|  1.05k|  return StatusWithSize(result.value().size());
  427|  1.11k|}
_ZN2pw8protobuf13StreamDecoder20ReadPackedFixedFieldENS_4spanISt4byteLm18446744073709551615EEEm:
  430|  2.30k|                                                   size_t elem_size) {
  431|  2.30k|  if (Status status = CheckOkToRead(WireType::kDelimited); !status.ok()) {
  ------------------
  |  Branch (431:60): [True: 30, False: 2.27k]
  ------------------
  432|     30|    return StatusWithSize(status, 0);
  433|     30|  }
  434|       |
  435|  2.27k|  if (reader_.ConservativeReadLimit() < delimited_field_size_) {
  ------------------
  |  Branch (435:7): [True: 34, False: 2.24k]
  ------------------
  436|     34|    status_ = Status::DataLoss();
  437|     34|    return StatusWithSize(status_, 0);
  438|     34|  }
  439|       |
  440|  2.24k|  if (out.size() < delimited_field_size_) {
  ------------------
  |  Branch (440:7): [True: 61, False: 2.18k]
  ------------------
  441|       |    // Value can't fit into the provided buffer. Don't advance the cursor so
  442|       |    // that the field can be re-read with a larger buffer or through the stream
  443|       |    // API.
  444|     61|    return StatusWithSize::ResourceExhausted();
  445|     61|  }
  446|       |
  447|  2.18k|  Result<ByteSpan> result = reader_.Read(out.first(delimited_field_size_));
  448|  2.18k|  if (!result.ok()) {
  ------------------
  |  Branch (448:7): [True: 148, False: 2.03k]
  ------------------
  449|    148|    return StatusWithSize(result.status(), 0);
  450|    148|  }
  451|       |
  452|  2.03k|  position_ += result.value().size();
  453|  2.03k|  field_consumed_ = true;
  454|       |
  455|       |  // Decode little-endian serialized packed fields.
  456|  2.03k|  if (endian::native != endian::little) {
  ------------------
  |  Branch (456:7): [Folded - Ignored]
  ------------------
  457|      0|    for (auto out_start = out.begin(); out_start != out.end();
  ------------------
  |  Branch (457:40): [True: 0, False: 0]
  ------------------
  458|      0|         out_start += elem_size) {
  459|      0|      std::reverse(out_start, out_start + elem_size);
  460|      0|    }
  461|      0|  }
  462|       |
  463|  2.03k|  return StatusWithSize(result.value().size() / elem_size);
  464|  2.18k|}
_ZN2pw8protobuf13StreamDecoder21ReadPackedVarintFieldENS_4spanISt4byteLm18446744073709551615EEEmNS0_8internal10VarintTypeE:
  468|  2.45k|                                                    VarintType decode_type) {
  469|  2.45k|  PW_CHECK(elem_size == sizeof(bool) || elem_size == sizeof(uint32_t) ||
  ------------------
  |  |   39|  2.45k|  do {                                                                         \
  |  |   40|  8.58k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:11): [True: 0, False: 2.45k]
  |  |  |  Branch (40:11): [True: 1.24k, False: 1.21k]
  |  |  |  Branch (40:11): [True: 1.21k, 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|  2.45k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  470|  2.45k|               elem_size == sizeof(uint64_t),
  471|  2.45k|           "Protobuf varints must only be used with bool, int32_t, uint32_t, "
  472|  2.45k|           "int64_t, or uint64_t");
  473|       |
  474|  2.45k|  if (Status status = CheckOkToRead(WireType::kDelimited); !status.ok()) {
  ------------------
  |  Branch (474:60): [True: 52, False: 2.40k]
  ------------------
  475|     52|    return StatusWithSize(status, 0);
  476|     52|  }
  477|       |
  478|  2.40k|  if (reader_.ConservativeReadLimit() < delimited_field_size_) {
  ------------------
  |  Branch (478:7): [True: 43, False: 2.36k]
  ------------------
  479|     43|    status_ = Status::DataLoss();
  480|     43|    return StatusWithSize(status_, 0);
  481|     43|  }
  482|       |
  483|  2.36k|  size_t bytes_read = 0;
  484|  2.36k|  size_t number_out = 0;
  485|  12.1k|  while (bytes_read < delimited_field_size_ && !out.empty()) {
  ------------------
  |  Branch (485:10): [True: 10.1k, False: 1.97k]
  |  Branch (485:48): [True: 10.1k, False: 11]
  ------------------
  486|  10.1k|    const StatusWithSize sws = ReadOneVarint(out.first(elem_size), decode_type);
  487|  10.1k|    if (!sws.ok()) {
  ------------------
  |  Branch (487:9): [True: 377, False: 9.76k]
  ------------------
  488|    377|      return StatusWithSize(sws.status(), number_out);
  489|    377|    }
  490|       |
  491|  9.76k|    bytes_read += sws.size();
  492|  9.76k|    out = out.subspan(elem_size);
  493|  9.76k|    ++number_out;
  494|  9.76k|  }
  495|       |
  496|  1.98k|  if (bytes_read < delimited_field_size_) {
  ------------------
  |  Branch (496:7): [True: 11, False: 1.97k]
  ------------------
  497|     11|    return StatusWithSize(Status::ResourceExhausted(), number_out);
  498|     11|  }
  499|       |
  500|  1.97k|  field_consumed_ = true;
  501|  1.97k|  return StatusWithSize(OkStatus(), number_out);
  502|  1.98k|}
_ZN2pw8protobuf13StreamDecoder13CheckOkToReadENS0_8WireTypeE:
  504|  13.3k|Status StreamDecoder::CheckOkToRead(WireType type) {
  505|  13.3k|  PW_CHECK(!nested_reader_open_,
  ------------------
  |  |   39|  13.3k|  do {                                                                         \
  |  |   40|  13.3k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 13.3k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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|  13.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  506|  13.3k|           "Cannot read from a decoder while a nested decoder is open");
  507|  13.3k|  PW_CHECK(!field_consumed_,
  ------------------
  |  |   39|  13.3k|  do {                                                                         \
  |  |   40|  13.3k|    if (!(condition)) {                                                        \
  |  |  ------------------
  |  |  |  Branch (40:9): [True: 0, False: 13.3k]
  |  |  ------------------
  |  |   41|      0|      _pw_assert_ConditionCannotContainThePercentCharacter(                    \
  |  |   42|      0|          #condition); /* cannot use '%' in PW_CHECK conditions */             \
  |  |   43|      0|      if (0) { /* Check args but don't execute to avoid multiple evaluation */ \
  |  |  ------------------
  |  |  |  Branch (43:11): [Folded - Ignored]
  |  |  ------------------
  |  |   44|      0|        _pw_assert_CheckMessageArguments(" " __VA_ARGS__);                     \
  |  |   45|      0|      }                                                                        \
  |  |   46|      0|      PW_HANDLE_ASSERT_FAILURE(#condition, "" __VA_ARGS__);                    \
  |  |  ------------------
  |  |  |  |   27|      0|  PW_ASSERT_PRINT_EXPRESSION("CHECK", condition_string); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   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|  13.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  508|  13.3k|           "Attempting to read from protobuf decoder without first calling "
  509|  13.3k|           "Next()");
  510|       |
  511|       |  // Attempting to read the wrong type is typically a programmer error;
  512|       |  // however, it could also occur due to data corruption. As we don't want to
  513|       |  // crash on bad data, return NOT_FOUND here to distinguish it from other
  514|       |  // corruption cases.
  515|  13.3k|  if (current_field_.wire_type() != type) {
  ------------------
  |  Branch (515:7): [True: 194, False: 13.1k]
  ------------------
  516|    194|    status_ = Status::NotFound();
  517|    194|  }
  518|       |
  519|  13.3k|  return status_;
  520|  13.3k|}

_ZN2pw6stream12MemoryReader6DoReadENS_4spanISt4byteLm18446744073709551615EEE:
   45|  49.7k|StatusWithSize MemoryReader::DoRead(ByteSpan dest) {
   46|  49.7k|  if (source_.size_bytes() == position_) {
  ------------------
  |  Branch (46:7): [True: 448, False: 49.2k]
  ------------------
   47|    448|    return StatusWithSize::OutOfRange();
   48|    448|  }
   49|       |
   50|  49.2k|  size_t bytes_to_read =
   51|  49.2k|      std::min(dest.size_bytes(), source_.size_bytes() - position_);
   52|  49.2k|  if (bytes_to_read == 0) {
  ------------------
  |  Branch (52:7): [True: 2.57k, False: 46.7k]
  ------------------
   53|       |    // Calling memcpy with a null pointer is undefined behavior, even when zero
   54|       |    // bytes are copied. We must return early here to avoid performing such a
   55|       |    // call when the dest span is empty.
   56|  2.57k|    return StatusWithSize(0);
   57|  2.57k|  }
   58|       |
   59|  46.7k|  std::memcpy(dest.data(), source_.data() + position_, bytes_to_read);
   60|  46.7k|  position_ += bytes_to_read;
   61|       |
   62|  46.7k|  return StatusWithSize(bytes_to_read);
   63|  49.2k|}

_ZN2pw6varint4ReadERNS_6stream6ReaderEPmm:
   39|  35.3k|StatusWithSize Read(stream::Reader& reader, uint64_t* output, size_t max_size) {
   40|  35.3k|  uint64_t value = 0;
   41|  35.3k|  size_t count = 0;
   42|       |
   43|  45.2k|  while (true) {
  ------------------
  |  Branch (43:10): [Folded - Ignored]
  ------------------
   44|  45.2k|    if (count >= varint::kMaxVarint64SizeBytes) {
  ------------------
  |  Branch (44:9): [True: 42, False: 45.1k]
  ------------------
   45|       |      // Varint can't fit a uint64_t, this likely means we're reading binary
   46|       |      // data that is not actually a varint.
   47|     42|      return StatusWithSize::DataLoss(count);
   48|     42|    }
   49|       |
   50|  45.1k|    if (count >= max_size) {
  ------------------
  |  Branch (50:9): [True: 304, False: 44.8k]
  ------------------
   51|       |      // Varint didn't fit within the range given; return OutOfRange() if
   52|       |      // max_size was 0, but DataLoss if we were reading something we thought
   53|       |      // was going to be a varint.
   54|    304|      return count > 0 ? StatusWithSize::DataLoss(count)
  ------------------
  |  Branch (54:14): [True: 298, False: 6]
  ------------------
   55|    304|                       : StatusWithSize::OutOfRange();
   56|    304|    }
   57|       |
   58|  44.8k|    std::byte b;
   59|  44.8k|    if (auto result = reader.Read(span(&b, 1)); !result.ok()) {
  ------------------
  |  Branch (59:49): [True: 245, False: 44.6k]
  ------------------
   60|    245|      if (count > 0 && result.status().IsOutOfRange()) {
  ------------------
  |  Branch (60:11): [True: 106, False: 139]
  |  Branch (60:24): [True: 106, False: 0]
  ------------------
   61|       |        // Status::OutOfRange on the first byte means we tried to read a varint
   62|       |        // when we reached the end of file. But after the first byte it means we
   63|       |        // failed to decode a varint we were in the middle of, and that's not
   64|       |        // a normal error condition.
   65|    106|        return StatusWithSize::DataLoss(count);
   66|    106|      }
   67|    139|      return StatusWithSize(result.status(), count);
   68|    245|    }
   69|       |
   70|  44.6k|    value |= static_cast<uint64_t>(b & std::byte(0b01111111)) << (7 * count);
   71|  44.6k|    ++count;
   72|       |
   73|       |    // MSB == 0 indicates last byte of the varint.
   74|  44.6k|    if ((b & std::byte(0b10000000)) == std::byte(0)) {
  ------------------
  |  Branch (74:9): [True: 34.7k, False: 9.84k]
  ------------------
   75|  34.7k|      break;
   76|  34.7k|    }
   77|  44.6k|  }
   78|       |
   79|  34.7k|  *output = value;
   80|  34.7k|  return StatusWithSize(count);
   81|  35.3k|}