pbrs 0.2.0

// @generated by protoc-gen-pbrs
#[allow(
    unused,
    non_snake_case,
    non_camel_case_types,
    clippy::all,
    unreachable_pub,
    reason = "generated by protoc-gen-pbrs"
)]
mod __gen {
    #![allow(
        unused,
        non_snake_case,
        non_camel_case_types,
        clippy::all,
        unsafe_code,
        unreachable_pub,
        reason = "generated by protoc-gen-pbrs"
    )]
    use pbrs::prelude::*;
    use pbrs::UnknownFields;
    use pbrs::{
        Enum, Map, MapMut, MapView, ParseError, ProtoBytes, ProtoString, Repeated, RepeatedMut,
        RepeatedView, SerializeError, UnknownEnumValue,
    };

    fn generated_pool() -> std::sync::Arc<pbrs::DescriptorPool> {
        pbrs::gencode::conformance_pool()
    }

    #[repr(transparent)]
    #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
    pub struct ForeignEnumEdition2023(i32);
    #[allow(non_upper_case_globals, reason = "protobuf enum names")]
    impl ForeignEnumEdition2023 {
        pub const ForeignFoo: ForeignEnumEdition2023 = ForeignEnumEdition2023(0);
        pub const ForeignBar: ForeignEnumEdition2023 = ForeignEnumEdition2023(1);
        pub const ForeignBaz: ForeignEnumEdition2023 = ForeignEnumEdition2023(2);
        fn constant_name(self) -> Option<&'static str> {
            #[allow(unreachable_patterns, reason = "open enums")]
            Some(match self.0 {
                0 => "ForeignFoo",
                1 => "ForeignBar",
                2 => "ForeignBaz",
                _ => return None,
            })
        }
    }
    impl From<ForeignEnumEdition2023> for i32 {
        fn from(v: ForeignEnumEdition2023) -> i32 {
            v.0
        }
    }
    impl From<i32> for ForeignEnumEdition2023 {
        fn from(val: i32) -> Self {
            Self(val)
        }
    }
    impl Default for ForeignEnumEdition2023 {
        fn default() -> Self {
            Self(0)
        }
    }
    impl std::fmt::Debug for ForeignEnumEdition2023 {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            if let Some(n) = self.constant_name() {
                write!(f, "ForeignEnumEdition2023::{n}")
            } else {
                write!(f, "ForeignEnumEdition2023::from({})", self.0)
            }
        }
    }
    impl pbrs::__internal::SealedInternal for ForeignEnumEdition2023 {}
    impl pbrs::Proxied for ForeignEnumEdition2023 {
        type View<'msg> = ForeignEnumEdition2023;
    }
    impl pbrs::AsView for ForeignEnumEdition2023 {
        type Proxied = Self;
        fn as_view(&self) -> Self {
            *self
        }
    }
    impl<'msg> pbrs::IntoView<'msg> for ForeignEnumEdition2023 {
        fn into_view<'shorter>(self) -> Self
        where
            'msg: 'shorter,
        {
            self
        }
    }
    impl Enum for ForeignEnumEdition2023 {
        const NAME: &'static str = "ForeignEnumEdition2023";
        fn is_known(value: i32) -> bool {
            matches!(value, 0 | 1 | 2)
        }
    }
    #[repr(transparent)]
    #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
    pub struct NestedEnum(i32);
    #[allow(non_upper_case_globals, reason = "protobuf enum names")]
    impl NestedEnum {
        pub const Foo: NestedEnum = NestedEnum(0);
        pub const Bar: NestedEnum = NestedEnum(1);
        pub const Baz: NestedEnum = NestedEnum(2);
        pub const Neg: NestedEnum = NestedEnum(-1);
        fn constant_name(self) -> Option<&'static str> {
            #[allow(unreachable_patterns, reason = "open enums")]
            Some(match self.0 {
                0 => "Foo",
                1 => "Bar",
                2 => "Baz",
                -1 => "Neg",
                _ => return None,
            })
        }
    }
    impl From<NestedEnum> for i32 {
        fn from(v: NestedEnum) -> i32 {
            v.0
        }
    }
    impl From<i32> for NestedEnum {
        fn from(val: i32) -> Self {
            Self(val)
        }
    }
    impl Default for NestedEnum {
        fn default() -> Self {
            Self(0)
        }
    }
    impl std::fmt::Debug for NestedEnum {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            if let Some(n) = self.constant_name() {
                write!(f, "NestedEnum::{n}")
            } else {
                write!(f, "NestedEnum::from({})", self.0)
            }
        }
    }
    impl pbrs::__internal::SealedInternal for NestedEnum {}
    impl pbrs::Proxied for NestedEnum {
        type View<'msg> = NestedEnum;
    }
    impl pbrs::AsView for NestedEnum {
        type Proxied = Self;
        fn as_view(&self) -> Self {
            *self
        }
    }
    impl<'msg> pbrs::IntoView<'msg> for NestedEnum {
        fn into_view<'shorter>(self) -> Self
        where
            'msg: 'shorter,
        {
            self
        }
    }
    impl Enum for NestedEnum {
        const NAME: &'static str = "NestedEnum";
        fn is_known(value: i32) -> bool {
            matches!(value, 0 | 1 | 2 | -1)
        }
    }
    #[derive(Clone, Debug)]
    pub struct ComplexMessage {
        d: Option<i32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for ComplexMessage {
        fn eq(&self, other: &Self) -> bool {
            if self.d != other.d {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for ComplexMessage {}
    impl Default for ComplexMessage {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl ComplexMessage {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.editions.ComplexMessage";
        pub fn has_d(&self) -> bool {
            self.d.is_some()
        }
        pub fn d(&self) -> i32 {
            self.d.unwrap_or(0)
        }
        pub fn d_opt(&self) -> Option<i32> {
            self.d.map(|v| v)
        }
        pub fn set_d(&mut self, v: i32) {
            self.cached_size.dirty();
            self.d = Some(v);
        }
        pub fn clear_d(&mut self) {
            self.cached_size.dirty();
            self.d = None;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.d = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    _ => self
                        .unknown
                        .fields
                        .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            if enforce {
                self.check_required()?;
            }
            Ok(())
        }
        fn validate_inner(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
        ) -> Result<(), ParseError> {
            Self::validate_until(wire, pos, depth, None)
        }
        fn validate_until(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let data = wire.as_slice();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    _ => pbrs::rt::skip_field(data, pos, w)?,
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            Ok(())
        }
        fn compute_size(&self) -> u64 {
            if let Some(n) = self.cached_size.get() {
                return n;
            }
            let mut n = self.unknown.encoded_len();
            if let Some(v) = self.d {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(v) = self.d {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("json"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.ComplexMessage")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("json"))?
                .to_json()
        }
        pub fn from_json(json: &str) -> Result<Self, ParseError> {
            Self::from_json_ignore(json, false)
        }
        pub fn from_json_ignore(json: &str, ignore: bool) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.ComplexMessage")
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_json_with_pool(desc, Some(pool), json, ignore)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.ComplexMessage")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text()
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.ComplexMessage")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text_with_unknown()
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.ComplexMessage")
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_text_with_pool(desc, Some(pool), text)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
    }
    pbrs::impl_typed_message!(ComplexMessage, ComplexMessageView, ComplexMessageMut);
    #[derive(Clone, Debug)]
    pub struct ForeignMessageEdition2023 {
        c: Option<i32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for ForeignMessageEdition2023 {
        fn eq(&self, other: &Self) -> bool {
            if self.c != other.c {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for ForeignMessageEdition2023 {}
    impl Default for ForeignMessageEdition2023 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl ForeignMessageEdition2023 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.editions.ForeignMessageEdition2023";
        pub fn has_c(&self) -> bool {
            self.c.is_some()
        }
        pub fn c(&self) -> i32 {
            self.c.unwrap_or(0)
        }
        pub fn c_opt(&self) -> Option<i32> {
            self.c.map(|v| v)
        }
        pub fn set_c(&mut self, v: i32) {
            self.cached_size.dirty();
            self.c = Some(v);
        }
        pub fn clear_c(&mut self) {
            self.cached_size.dirty();
            self.c = None;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.c = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    _ => self
                        .unknown
                        .fields
                        .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            if enforce {
                self.check_required()?;
            }
            Ok(())
        }
        fn validate_inner(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
        ) -> Result<(), ParseError> {
            Self::validate_until(wire, pos, depth, None)
        }
        fn validate_until(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let data = wire.as_slice();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    _ => pbrs::rt::skip_field(data, pos, w)?,
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            Ok(())
        }
        fn compute_size(&self) -> u64 {
            if let Some(n) = self.cached_size.get() {
                return n;
            }
            let mut n = self.unknown.encoded_len();
            if let Some(v) = self.c {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(v) = self.c {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("json"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.ForeignMessageEdition2023")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("json"))?
                .to_json()
        }
        pub fn from_json(json: &str) -> Result<Self, ParseError> {
            Self::from_json_ignore(json, false)
        }
        pub fn from_json_ignore(json: &str, ignore: bool) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.ForeignMessageEdition2023")
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_json_with_pool(desc, Some(pool), json, ignore)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.ForeignMessageEdition2023")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text()
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.ForeignMessageEdition2023")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text_with_unknown()
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.ForeignMessageEdition2023")
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_text_with_pool(desc, Some(pool), text)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
    }
    pbrs::impl_typed_message!(
        ForeignMessageEdition2023,
        ForeignMessageEdition2023View,
        ForeignMessageEdition2023Mut
    );
    #[derive(Clone, Debug)]
    pub struct GroupLikeType {
        c: Option<i32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for GroupLikeType {
        fn eq(&self, other: &Self) -> bool {
            if self.c != other.c {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for GroupLikeType {}
    impl Default for GroupLikeType {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl GroupLikeType {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.editions.GroupLikeType";
        pub fn has_c(&self) -> bool {
            self.c.is_some()
        }
        pub fn c(&self) -> i32 {
            self.c.unwrap_or(0)
        }
        pub fn c_opt(&self) -> Option<i32> {
            self.c.map(|v| v)
        }
        pub fn set_c(&mut self, v: i32) {
            self.cached_size.dirty();
            self.c = Some(v);
        }
        pub fn clear_c(&mut self) {
            self.cached_size.dirty();
            self.c = None;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.c = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    _ => self
                        .unknown
                        .fields
                        .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            if enforce {
                self.check_required()?;
            }
            Ok(())
        }
        fn validate_inner(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
        ) -> Result<(), ParseError> {
            Self::validate_until(wire, pos, depth, None)
        }
        fn validate_until(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let data = wire.as_slice();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    _ => pbrs::rt::skip_field(data, pos, w)?,
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            Ok(())
        }
        fn compute_size(&self) -> u64 {
            if let Some(n) = self.cached_size.get() {
                return n;
            }
            let mut n = self.unknown.encoded_len();
            if let Some(v) = self.c {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(v) = self.c {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("json"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.GroupLikeType")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("json"))?
                .to_json()
        }
        pub fn from_json(json: &str) -> Result<Self, ParseError> {
            Self::from_json_ignore(json, false)
        }
        pub fn from_json_ignore(json: &str, ignore: bool) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.GroupLikeType")
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_json_with_pool(desc, Some(pool), json, ignore)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.GroupLikeType")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text()
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.GroupLikeType")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text_with_unknown()
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.GroupLikeType")
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_text_with_pool(desc, Some(pool), text)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
    }
    pbrs::impl_typed_message!(GroupLikeType, GroupLikeTypeView, GroupLikeTypeMut);
    #[derive(Clone, Debug, PartialEq)]
    struct TestAllTypesEdition2023Cold {
        repeated_int32: pbrs::rt::PackedI32,
        repeated_int64: pbrs::rt::PackedI64,
        repeated_uint32: pbrs::rt::PackedU32,
        repeated_uint64: pbrs::rt::PackedU64,
        repeated_sint32: pbrs::rt::PackedS32,
        repeated_sint64: pbrs::rt::PackedS64,
        repeated_fixed32: pbrs::rt::PackedFx32,
        repeated_fixed64: pbrs::rt::PackedFx64,
        repeated_sfixed32: pbrs::rt::PackedSfx32,
        repeated_sfixed64: pbrs::rt::PackedSfx64,
        repeated_float: pbrs::rt::PackedF32,
        repeated_double: pbrs::rt::PackedF64,
        repeated_bool: pbrs::rt::PackedBool,
        repeated_foreign_message: Repeated<ForeignMessageEdition2023>,
        repeated_nested_enum: pbrs::rt::PackedI32,
        repeated_foreign_enum: pbrs::rt::PackedI32,
        packed_int32: pbrs::rt::PackedI32,
        packed_int64: pbrs::rt::PackedI64,
        packed_uint32: pbrs::rt::PackedU32,
        packed_uint64: pbrs::rt::PackedU64,
        packed_sint32: pbrs::rt::PackedS32,
        packed_sint64: pbrs::rt::PackedS64,
        packed_sfixed32: pbrs::rt::PackedSfx32,
        packed_sfixed64: pbrs::rt::PackedSfx64,
        packed_double: pbrs::rt::PackedF64,
        packed_bool: pbrs::rt::PackedBool,
        packed_nested_enum: pbrs::rt::PackedI32,
        unpacked_int32: Repeated<i32>,
        unpacked_int64: Repeated<i64>,
        unpacked_uint32: Repeated<u32>,
        unpacked_uint64: Repeated<u64>,
        unpacked_sint32: Repeated<i32>,
        unpacked_sint64: Repeated<i64>,
        unpacked_fixed32: Repeated<u32>,
        unpacked_fixed64: Repeated<u64>,
        unpacked_sfixed32: Repeated<i32>,
        unpacked_sfixed64: Repeated<i64>,
        unpacked_float: Repeated<f32>,
        unpacked_double: Repeated<f64>,
        unpacked_bool: Repeated<bool>,
        unpacked_nested_enum: Repeated<i32>,
    }
    impl Default for TestAllTypesEdition2023Cold {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TestAllTypesEdition2023 {
        optional_int32: Option<i32>,
        optional_int64: Option<i64>,
        optional_uint32: Option<u32>,
        optional_uint64: Option<u64>,
        optional_sint32: Option<i32>,
        optional_sint64: Option<i64>,
        optional_fixed32: Option<u32>,
        optional_fixed64: Option<u64>,
        optional_sfixed32: Option<i32>,
        optional_sfixed64: Option<i64>,
        optional_float: Option<f32>,
        optional_double: Option<f64>,
        optional_bool: pbrs::rt::OptBool,
        optional_string: Option<Box<pbrs::rt::LazyStr>>,
        optional_bytes: Option<Box<pbrs::rt::LazyBytes>>,
        optional_nested_message: pbrs::rt::LazyMsg<NestedMessage>,
        optional_foreign_message: pbrs::rt::LazyMsg<ForeignMessageEdition2023>,
        optional_nested_enum: Option<i32>,
        optional_foreign_enum: Option<i32>,
        optional_string_piece: Option<Box<pbrs::rt::LazyStr>>,
        optional_cord: Option<Box<pbrs::rt::LazyStr>>,
        recursive_message: pbrs::rt::LazyMsg<TestAllTypesEdition2023>,
        repeated_string: Repeated<pbrs::rt::LazyStr>,
        repeated_bytes: Repeated<pbrs::rt::LazyBytes>,
        repeated_nested_message: Repeated<NestedMessage>,
        repeated_string_piece: Repeated<pbrs::rt::LazyStr>,
        repeated_cord: Repeated<pbrs::rt::LazyStr>,
        map_int32_int32: Map<i32, i32>,
        map_int64_int64: Map<i64, i64>,
        map_uint32_uint32: Map<u32, u32>,
        map_uint64_uint64: Map<u64, u64>,
        map_sint32_sint32: Map<i32, i32>,
        map_sint64_sint64: Map<i64, i64>,
        map_fixed32_fixed32: Map<u32, u32>,
        map_fixed64_fixed64: Map<u64, u64>,
        map_sfixed32_sfixed32: Map<i32, i32>,
        map_sfixed64_sfixed64: Map<i64, i64>,
        map_int32_float: Map<i32, f32>,
        map_int32_double: Map<i32, f64>,
        map_bool_bool: Map<bool, bool>,
        map_string_string: Map<pbrs::rt::LazyStr, pbrs::rt::LazyStr>,
        map_string_bytes: Map<pbrs::rt::LazyStr, pbrs::rt::LazyBytes>,
        map_string_nested_message: Map<pbrs::rt::LazyStr, NestedMessage>,
        map_string_foreign_message: Map<pbrs::rt::LazyStr, ForeignMessageEdition2023>,
        map_string_nested_enum: Map<pbrs::rt::LazyStr, i32>,
        map_string_foreign_enum: Map<pbrs::rt::LazyStr, i32>,
        packed_fixed32: pbrs::rt::PackedFx32,
        packed_fixed64: pbrs::rt::PackedFx64,
        packed_float: pbrs::rt::PackedF32,
        oneof_uint32: Option<u32>,
        oneof_nested_message: pbrs::rt::LazyMsg<NestedMessage>,
        oneof_string: Option<Box<pbrs::rt::LazyStr>>,
        oneof_bytes: Option<Box<pbrs::rt::LazyBytes>>,
        oneof_bool: pbrs::rt::OptBool,
        oneof_uint64: Option<u64>,
        oneof_float: Option<f32>,
        oneof_double: Option<f64>,
        oneof_enum: Option<i32>,
        extension_int32: Option<i32>,
        groupliketype: Option<Box<GroupLikeType>>,
        delimited_ext: Option<Box<GroupLikeType>>,
        extension_string: Option<Box<pbrs::rt::LazyStr>>,
        extension_bytes: Option<Box<pbrs::rt::LazyBytes>>,
        groupliketype_201: Option<Box<TestAllTypesEdition2023GroupLikeType>>,
        delimited_field: Option<Box<TestAllTypesEdition2023GroupLikeType>>,
        map_recursive: Map<i32, TestAllTypesEdition2023>,
        cold: Option<Box<TestAllTypesEdition2023Cold>>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for TestAllTypesEdition2023 {
        fn eq(&self, other: &Self) -> bool {
            if self.optional_int32 != other.optional_int32 {
                return false;
            }
            if self.optional_int64 != other.optional_int64 {
                return false;
            }
            if self.optional_uint32 != other.optional_uint32 {
                return false;
            }
            if self.optional_uint64 != other.optional_uint64 {
                return false;
            }
            if self.optional_sint32 != other.optional_sint32 {
                return false;
            }
            if self.optional_sint64 != other.optional_sint64 {
                return false;
            }
            if self.optional_fixed32 != other.optional_fixed32 {
                return false;
            }
            if self.optional_fixed64 != other.optional_fixed64 {
                return false;
            }
            if self.optional_sfixed32 != other.optional_sfixed32 {
                return false;
            }
            if self.optional_sfixed64 != other.optional_sfixed64 {
                return false;
            }
            if self.optional_float != other.optional_float {
                return false;
            }
            if self.optional_double != other.optional_double {
                return false;
            }
            if self.optional_bool != other.optional_bool {
                return false;
            }
            if self.optional_string != other.optional_string {
                return false;
            }
            if self.optional_bytes != other.optional_bytes {
                return false;
            }
            if self.optional_nested_message != other.optional_nested_message {
                return false;
            }
            if self.optional_foreign_message != other.optional_foreign_message {
                return false;
            }
            if self.optional_nested_enum != other.optional_nested_enum {
                return false;
            }
            if self.optional_foreign_enum != other.optional_foreign_enum {
                return false;
            }
            if self.optional_string_piece != other.optional_string_piece {
                return false;
            }
            if self.optional_cord != other.optional_cord {
                return false;
            }
            if self.recursive_message != other.recursive_message {
                return false;
            }
            if self.repeated_string != other.repeated_string {
                return false;
            }
            if self.repeated_bytes != other.repeated_bytes {
                return false;
            }
            if self.repeated_nested_message != other.repeated_nested_message {
                return false;
            }
            if self.repeated_string_piece != other.repeated_string_piece {
                return false;
            }
            if self.repeated_cord != other.repeated_cord {
                return false;
            }
            if self.map_int32_int32 != other.map_int32_int32 {
                return false;
            }
            if self.map_int64_int64 != other.map_int64_int64 {
                return false;
            }
            if self.map_uint32_uint32 != other.map_uint32_uint32 {
                return false;
            }
            if self.map_uint64_uint64 != other.map_uint64_uint64 {
                return false;
            }
            if self.map_sint32_sint32 != other.map_sint32_sint32 {
                return false;
            }
            if self.map_sint64_sint64 != other.map_sint64_sint64 {
                return false;
            }
            if self.map_fixed32_fixed32 != other.map_fixed32_fixed32 {
                return false;
            }
            if self.map_fixed64_fixed64 != other.map_fixed64_fixed64 {
                return false;
            }
            if self.map_sfixed32_sfixed32 != other.map_sfixed32_sfixed32 {
                return false;
            }
            if self.map_sfixed64_sfixed64 != other.map_sfixed64_sfixed64 {
                return false;
            }
            if self.map_int32_float != other.map_int32_float {
                return false;
            }
            if self.map_int32_double != other.map_int32_double {
                return false;
            }
            if self.map_bool_bool != other.map_bool_bool {
                return false;
            }
            if self.map_string_string != other.map_string_string {
                return false;
            }
            if self.map_string_bytes != other.map_string_bytes {
                return false;
            }
            if self.map_string_nested_message != other.map_string_nested_message {
                return false;
            }
            if self.map_string_foreign_message != other.map_string_foreign_message {
                return false;
            }
            if self.map_string_nested_enum != other.map_string_nested_enum {
                return false;
            }
            if self.map_string_foreign_enum != other.map_string_foreign_enum {
                return false;
            }
            if self.packed_fixed32 != other.packed_fixed32 {
                return false;
            }
            if self.packed_fixed64 != other.packed_fixed64 {
                return false;
            }
            if self.packed_float != other.packed_float {
                return false;
            }
            if self.oneof_uint32 != other.oneof_uint32 {
                return false;
            }
            if self.oneof_nested_message != other.oneof_nested_message {
                return false;
            }
            if self.oneof_string != other.oneof_string {
                return false;
            }
            if self.oneof_bytes != other.oneof_bytes {
                return false;
            }
            if self.oneof_bool != other.oneof_bool {
                return false;
            }
            if self.oneof_uint64 != other.oneof_uint64 {
                return false;
            }
            if self.oneof_float != other.oneof_float {
                return false;
            }
            if self.oneof_double != other.oneof_double {
                return false;
            }
            if self.oneof_enum != other.oneof_enum {
                return false;
            }
            if self.extension_int32 != other.extension_int32 {
                return false;
            }
            if self.groupliketype != other.groupliketype {
                return false;
            }
            if self.delimited_ext != other.delimited_ext {
                return false;
            }
            if self.extension_string != other.extension_string {
                return false;
            }
            if self.extension_bytes != other.extension_bytes {
                return false;
            }
            if self.groupliketype_201 != other.groupliketype_201 {
                return false;
            }
            if self.delimited_field != other.delimited_field {
                return false;
            }
            if self.map_recursive != other.map_recursive {
                return false;
            }
            match (self.cold.as_deref(), other.cold.as_deref()) {
                (None, None) => {}
                (Some(a), Some(b)) => {
                    if a != b {
                        return false;
                    }
                }
                (None, Some(b)) => {
                    if *b != TestAllTypesEdition2023Cold::default() {
                        return false;
                    }
                }
                (Some(a), None) => {
                    if *a != TestAllTypesEdition2023Cold::default() {
                        return false;
                    }
                }
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for TestAllTypesEdition2023 {}
    impl Default for TestAllTypesEdition2023 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl TestAllTypesEdition2023 {
        pub fn new() -> Self {
            Self::default()
        }
        #[inline(always)]
        fn cold_mut(&mut self) -> &mut TestAllTypesEdition2023Cold {
            self.cold
                .get_or_insert_with(|| Box::new(TestAllTypesEdition2023Cold::default()))
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.editions.TestAllTypesEdition2023";
        pub fn has_optional_int32(&self) -> bool {
            self.optional_int32.is_some()
        }
        pub fn optional_int32(&self) -> i32 {
            self.optional_int32.unwrap_or(0)
        }
        pub fn optional_int32_opt(&self) -> Option<i32> {
            self.optional_int32.map(|v| v)
        }
        pub fn set_optional_int32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.optional_int32 = Some(v);
        }
        pub fn clear_optional_int32(&mut self) {
            self.cached_size.dirty();
            self.optional_int32 = None;
        }
        pub fn has_optional_int64(&self) -> bool {
            self.optional_int64.is_some()
        }
        pub fn optional_int64(&self) -> i64 {
            self.optional_int64.unwrap_or(0)
        }
        pub fn optional_int64_opt(&self) -> Option<i64> {
            self.optional_int64.map(|v| v)
        }
        pub fn set_optional_int64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.optional_int64 = Some(v);
        }
        pub fn clear_optional_int64(&mut self) {
            self.cached_size.dirty();
            self.optional_int64 = None;
        }
        pub fn has_optional_uint32(&self) -> bool {
            self.optional_uint32.is_some()
        }
        pub fn optional_uint32(&self) -> u32 {
            self.optional_uint32.unwrap_or(0)
        }
        pub fn optional_uint32_opt(&self) -> Option<u32> {
            self.optional_uint32.map(|v| v)
        }
        pub fn set_optional_uint32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.optional_uint32 = Some(v);
        }
        pub fn clear_optional_uint32(&mut self) {
            self.cached_size.dirty();
            self.optional_uint32 = None;
        }
        pub fn has_optional_uint64(&self) -> bool {
            self.optional_uint64.is_some()
        }
        pub fn optional_uint64(&self) -> u64 {
            self.optional_uint64.unwrap_or(0)
        }
        pub fn optional_uint64_opt(&self) -> Option<u64> {
            self.optional_uint64.map(|v| v)
        }
        pub fn set_optional_uint64(&mut self, v: u64) {
            self.cached_size.dirty();
            self.optional_uint64 = Some(v);
        }
        pub fn clear_optional_uint64(&mut self) {
            self.cached_size.dirty();
            self.optional_uint64 = None;
        }
        pub fn has_optional_sint32(&self) -> bool {
            self.optional_sint32.is_some()
        }
        pub fn optional_sint32(&self) -> i32 {
            self.optional_sint32.unwrap_or(0)
        }
        pub fn optional_sint32_opt(&self) -> Option<i32> {
            self.optional_sint32.map(|v| v)
        }
        pub fn set_optional_sint32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.optional_sint32 = Some(v);
        }
        pub fn clear_optional_sint32(&mut self) {
            self.cached_size.dirty();
            self.optional_sint32 = None;
        }
        pub fn has_optional_sint64(&self) -> bool {
            self.optional_sint64.is_some()
        }
        pub fn optional_sint64(&self) -> i64 {
            self.optional_sint64.unwrap_or(0)
        }
        pub fn optional_sint64_opt(&self) -> Option<i64> {
            self.optional_sint64.map(|v| v)
        }
        pub fn set_optional_sint64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.optional_sint64 = Some(v);
        }
        pub fn clear_optional_sint64(&mut self) {
            self.cached_size.dirty();
            self.optional_sint64 = None;
        }
        pub fn has_optional_fixed32(&self) -> bool {
            self.optional_fixed32.is_some()
        }
        pub fn optional_fixed32(&self) -> u32 {
            self.optional_fixed32.unwrap_or(0)
        }
        pub fn optional_fixed32_opt(&self) -> Option<u32> {
            self.optional_fixed32.map(|v| v)
        }
        pub fn set_optional_fixed32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.optional_fixed32 = Some(v);
        }
        pub fn clear_optional_fixed32(&mut self) {
            self.cached_size.dirty();
            self.optional_fixed32 = None;
        }
        pub fn has_optional_fixed64(&self) -> bool {
            self.optional_fixed64.is_some()
        }
        pub fn optional_fixed64(&self) -> u64 {
            self.optional_fixed64.unwrap_or(0)
        }
        pub fn optional_fixed64_opt(&self) -> Option<u64> {
            self.optional_fixed64.map(|v| v)
        }
        pub fn set_optional_fixed64(&mut self, v: u64) {
            self.cached_size.dirty();
            self.optional_fixed64 = Some(v);
        }
        pub fn clear_optional_fixed64(&mut self) {
            self.cached_size.dirty();
            self.optional_fixed64 = None;
        }
        pub fn has_optional_sfixed32(&self) -> bool {
            self.optional_sfixed32.is_some()
        }
        pub fn optional_sfixed32(&self) -> i32 {
            self.optional_sfixed32.unwrap_or(0)
        }
        pub fn optional_sfixed32_opt(&self) -> Option<i32> {
            self.optional_sfixed32.map(|v| v)
        }
        pub fn set_optional_sfixed32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.optional_sfixed32 = Some(v);
        }
        pub fn clear_optional_sfixed32(&mut self) {
            self.cached_size.dirty();
            self.optional_sfixed32 = None;
        }
        pub fn has_optional_sfixed64(&self) -> bool {
            self.optional_sfixed64.is_some()
        }
        pub fn optional_sfixed64(&self) -> i64 {
            self.optional_sfixed64.unwrap_or(0)
        }
        pub fn optional_sfixed64_opt(&self) -> Option<i64> {
            self.optional_sfixed64.map(|v| v)
        }
        pub fn set_optional_sfixed64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.optional_sfixed64 = Some(v);
        }
        pub fn clear_optional_sfixed64(&mut self) {
            self.cached_size.dirty();
            self.optional_sfixed64 = None;
        }
        pub fn has_optional_float(&self) -> bool {
            self.optional_float.is_some()
        }
        pub fn optional_float(&self) -> f32 {
            self.optional_float.unwrap_or(0.0)
        }
        pub fn optional_float_opt(&self) -> Option<f32> {
            self.optional_float.map(|v| v)
        }
        pub fn set_optional_float(&mut self, v: f32) {
            self.cached_size.dirty();
            self.optional_float = Some(v);
        }
        pub fn clear_optional_float(&mut self) {
            self.cached_size.dirty();
            self.optional_float = None;
        }
        pub fn has_optional_double(&self) -> bool {
            self.optional_double.is_some()
        }
        pub fn optional_double(&self) -> f64 {
            self.optional_double.unwrap_or(0.0)
        }
        pub fn optional_double_opt(&self) -> Option<f64> {
            self.optional_double.map(|v| v)
        }
        pub fn set_optional_double(&mut self, v: f64) {
            self.cached_size.dirty();
            self.optional_double = Some(v);
        }
        pub fn clear_optional_double(&mut self) {
            self.cached_size.dirty();
            self.optional_double = None;
        }
        pub fn has_optional_bool(&self) -> bool {
            self.optional_bool.is_some()
        }
        pub fn optional_bool(&self) -> bool {
            self.optional_bool.unwrap_or(false)
        }
        pub fn optional_bool_opt(&self) -> Option<bool> {
            self.optional_bool.get()
        }
        pub fn set_optional_bool(&mut self, v: bool) {
            self.cached_size.dirty();
            self.optional_bool = pbrs::rt::OptBool::some(v);
        }
        pub fn clear_optional_bool(&mut self) {
            self.cached_size.dirty();
            self.optional_bool = pbrs::rt::OptBool::NONE;
        }
        pub fn has_optional_string(&self) -> bool {
            self.optional_string.is_some()
        }
        pub fn optional_string(&self) -> &pbrs::ProtoStr {
            self.optional_string
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn optional_string_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.optional_string.as_ref().map(|s| s.as_view())
        }
        pub fn set_optional_string(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.optional_string = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_optional_string(&mut self) {
            self.cached_size.dirty();
            self.optional_string = None;
        }
        pub fn optional_bytes(&self) -> &[u8] {
            self.optional_bytes
                .as_ref()
                .map(|b| b.as_bytes())
                .unwrap_or(b"")
        }
        pub fn optional_bytes_opt(&self) -> Option<&[u8]> {
            self.optional_bytes.as_ref().map(|b| b.as_bytes())
        }
        pub fn has_optional_bytes(&self) -> bool {
            self.optional_bytes.is_some()
        }
        pub fn set_optional_bytes(&mut self, v: impl pbrs::IntoProxied<ProtoBytes>) {
            self.cached_size.dirty();
            self.optional_bytes = Some(Box::new(pbrs::rt::LazyBytes::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_optional_bytes(&mut self) {
            self.cached_size.dirty();
            self.optional_bytes = None;
        }
        pub fn has_optional_nested_message(&self) -> bool {
            self.optional_nested_message.is_some()
        }
        pub fn optional_nested_message(&self) -> &NestedMessage {
            self.optional_nested_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_nested_message_opt(&self) -> Option<&NestedMessage> {
            self.optional_nested_message.as_deref()
        }
        pub fn optional_nested_message_view(&self) -> NestedMessageView<'_> {
            NestedMessageView(self.optional_nested_message())
        }
        pub fn set_optional_nested_message(&mut self, v: NestedMessage) {
            self.cached_size.dirty();
            self.optional_nested_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_nested_message_mut(&mut self) -> &mut NestedMessage {
            self.cached_size.dirty();
            self.optional_nested_message.get_or_insert()
        }
        pub fn clear_optional_nested_message(&mut self) {
            self.cached_size.dirty();
            self.optional_nested_message.clear();
        }
        pub fn has_optional_foreign_message(&self) -> bool {
            self.optional_foreign_message.is_some()
        }
        pub fn optional_foreign_message(&self) -> &ForeignMessageEdition2023 {
            self.optional_foreign_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_foreign_message_opt(&self) -> Option<&ForeignMessageEdition2023> {
            self.optional_foreign_message.as_deref()
        }
        pub fn optional_foreign_message_view(&self) -> ForeignMessageEdition2023View<'_> {
            ForeignMessageEdition2023View(self.optional_foreign_message())
        }
        pub fn set_optional_foreign_message(&mut self, v: ForeignMessageEdition2023) {
            self.cached_size.dirty();
            self.optional_foreign_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_foreign_message_mut(&mut self) -> &mut ForeignMessageEdition2023 {
            self.cached_size.dirty();
            self.optional_foreign_message.get_or_insert()
        }
        pub fn clear_optional_foreign_message(&mut self) {
            self.cached_size.dirty();
            self.optional_foreign_message.clear();
        }
        pub fn has_optional_nested_enum(&self) -> bool {
            self.optional_nested_enum.is_some()
        }
        pub fn optional_nested_enum(&self) -> NestedEnum {
            NestedEnum(self.optional_nested_enum.unwrap_or(0))
        }
        pub fn optional_nested_enum_opt(&self) -> Option<NestedEnum> {
            self.optional_nested_enum.map(|v| NestedEnum(v))
        }
        pub fn set_optional_nested_enum(&mut self, v: impl Into<i32>) {
            self.cached_size.dirty();
            self.optional_nested_enum = Some(v.into());
        }
        pub fn clear_optional_nested_enum(&mut self) {
            self.cached_size.dirty();
            self.optional_nested_enum = None;
        }
        pub fn has_optional_foreign_enum(&self) -> bool {
            self.optional_foreign_enum.is_some()
        }
        pub fn optional_foreign_enum(&self) -> ForeignEnumEdition2023 {
            ForeignEnumEdition2023(self.optional_foreign_enum.unwrap_or(0))
        }
        pub fn optional_foreign_enum_opt(&self) -> Option<ForeignEnumEdition2023> {
            self.optional_foreign_enum
                .map(|v| ForeignEnumEdition2023(v))
        }
        pub fn set_optional_foreign_enum(&mut self, v: impl Into<i32>) {
            self.cached_size.dirty();
            self.optional_foreign_enum = Some(v.into());
        }
        pub fn clear_optional_foreign_enum(&mut self) {
            self.cached_size.dirty();
            self.optional_foreign_enum = None;
        }
        pub fn has_optional_string_piece(&self) -> bool {
            self.optional_string_piece.is_some()
        }
        pub fn optional_string_piece(&self) -> &pbrs::ProtoStr {
            self.optional_string_piece
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn optional_string_piece_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.optional_string_piece.as_ref().map(|s| s.as_view())
        }
        pub fn set_optional_string_piece(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.optional_string_piece = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_optional_string_piece(&mut self) {
            self.cached_size.dirty();
            self.optional_string_piece = None;
        }
        pub fn has_optional_cord(&self) -> bool {
            self.optional_cord.is_some()
        }
        pub fn optional_cord(&self) -> &pbrs::ProtoStr {
            self.optional_cord
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn optional_cord_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.optional_cord.as_ref().map(|s| s.as_view())
        }
        pub fn set_optional_cord(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.optional_cord = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_optional_cord(&mut self) {
            self.cached_size.dirty();
            self.optional_cord = None;
        }
        pub fn has_recursive_message(&self) -> bool {
            self.recursive_message.is_some()
        }
        pub fn recursive_message(&self) -> &TestAllTypesEdition2023 {
            self.recursive_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn recursive_message_opt(&self) -> Option<&TestAllTypesEdition2023> {
            self.recursive_message.as_deref()
        }
        pub fn recursive_message_view(&self) -> TestAllTypesEdition2023View<'_> {
            TestAllTypesEdition2023View(self.recursive_message())
        }
        pub fn set_recursive_message(&mut self, v: TestAllTypesEdition2023) {
            self.cached_size.dirty();
            self.recursive_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn recursive_message_mut(&mut self) -> &mut TestAllTypesEdition2023 {
            self.cached_size.dirty();
            self.recursive_message.get_or_insert()
        }
        pub fn clear_recursive_message(&mut self) {
            self.cached_size.dirty();
            self.recursive_message.clear();
        }
        pub fn repeated_int32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_int32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_int32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_int32.as_mut()
        }
        pub fn set_repeated_int32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_int32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_int64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_int64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_int64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_int64.as_mut()
        }
        pub fn set_repeated_int64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_int64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_uint32(&self) -> RepeatedView<'_, u32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_uint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_uint32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint32.as_mut()
        }
        pub fn set_repeated_uint32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_uint64(&self) -> RepeatedView<'_, u64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_uint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_uint64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint64.as_mut()
        }
        pub fn set_repeated_uint64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_sint32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_sint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_sint32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_sint32.as_mut()
        }
        pub fn set_repeated_sint32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_sint32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_sint64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_sint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_sint64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_sint64.as_mut()
        }
        pub fn set_repeated_sint64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_sint64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_fixed32(&self) -> RepeatedView<'_, u32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_fixed32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_fixed32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_fixed32.as_mut()
        }
        pub fn set_repeated_fixed32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_fixed32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_fixed64(&self) -> RepeatedView<'_, u64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_fixed64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_fixed64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_fixed64.as_mut()
        }
        pub fn set_repeated_fixed64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_fixed64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_sfixed32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_sfixed32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_sfixed32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_sfixed32.as_mut()
        }
        pub fn set_repeated_sfixed32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_sfixed32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_sfixed64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_sfixed64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_sfixed64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_sfixed64.as_mut()
        }
        pub fn set_repeated_sfixed64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_sfixed64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_float(&self) -> RepeatedView<'_, f32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_float.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_float_mut(&mut self) -> RepeatedMut<'_, f32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_float.as_mut()
        }
        pub fn set_repeated_float(&mut self, v: impl IntoIterator<Item = f32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_float =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_double(&self) -> RepeatedView<'_, f64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_double.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_double_mut(&mut self) -> RepeatedMut<'_, f64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_double.as_mut()
        }
        pub fn set_repeated_double(&mut self, v: impl IntoIterator<Item = f64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_double =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_bool(&self) -> RepeatedView<'_, bool> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_bool.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_bool_mut(&mut self) -> RepeatedMut<'_, bool> {
            self.cached_size.dirty();
            self.cold_mut().repeated_bool.as_mut()
        }
        pub fn set_repeated_bool(&mut self, v: impl IntoIterator<Item = bool>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_bool =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_string(&self) -> RepeatedView<'_, pbrs::rt::LazyStr> {
            self.repeated_string.as_view()
        }
        pub fn repeated_string_mut(&mut self) -> RepeatedMut<'_, pbrs::rt::LazyStr> {
            self.cached_size.dirty();
            self.repeated_string.as_mut()
        }
        pub fn set_repeated_string(&mut self, v: impl IntoIterator<Item = pbrs::rt::LazyStr>) {
            self.cached_size.dirty();
            self.repeated_string = v.into_iter().collect();
        }
        pub fn repeated_bytes(&self) -> RepeatedView<'_, pbrs::rt::LazyBytes> {
            self.repeated_bytes.as_view()
        }
        pub fn repeated_bytes_mut(&mut self) -> RepeatedMut<'_, pbrs::rt::LazyBytes> {
            self.cached_size.dirty();
            self.repeated_bytes.as_mut()
        }
        pub fn set_repeated_bytes(&mut self, v: impl IntoIterator<Item = pbrs::rt::LazyBytes>) {
            self.cached_size.dirty();
            self.repeated_bytes = v.into_iter().collect();
        }
        pub fn repeated_nested_message(&self) -> RepeatedView<'_, NestedMessage> {
            self.repeated_nested_message.as_view()
        }
        pub fn repeated_nested_message_mut(&mut self) -> RepeatedMut<'_, NestedMessage> {
            self.cached_size.dirty();
            self.repeated_nested_message.as_mut()
        }
        pub fn set_repeated_nested_message(&mut self, v: impl IntoIterator<Item = NestedMessage>) {
            self.cached_size.dirty();
            self.repeated_nested_message = v.into_iter().collect();
        }
        pub fn repeated_foreign_message(&self) -> RepeatedView<'_, ForeignMessageEdition2023> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_foreign_message.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_foreign_message_mut(
            &mut self,
        ) -> RepeatedMut<'_, ForeignMessageEdition2023> {
            self.cached_size.dirty();
            self.cold_mut().repeated_foreign_message.as_mut()
        }
        pub fn set_repeated_foreign_message(
            &mut self,
            v: impl IntoIterator<Item = ForeignMessageEdition2023>,
        ) {
            self.cached_size.dirty();
            self.cold_mut().repeated_foreign_message = v.into_iter().collect();
        }
        pub fn repeated_nested_enum(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_nested_enum.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_nested_enum_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_nested_enum.as_mut()
        }
        pub fn set_repeated_nested_enum(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_nested_enum =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_foreign_enum(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_foreign_enum.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_foreign_enum_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_foreign_enum.as_mut()
        }
        pub fn set_repeated_foreign_enum(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_foreign_enum =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_string_piece(&self) -> RepeatedView<'_, pbrs::rt::LazyStr> {
            self.repeated_string_piece.as_view()
        }
        pub fn repeated_string_piece_mut(&mut self) -> RepeatedMut<'_, pbrs::rt::LazyStr> {
            self.cached_size.dirty();
            self.repeated_string_piece.as_mut()
        }
        pub fn set_repeated_string_piece(
            &mut self,
            v: impl IntoIterator<Item = pbrs::rt::LazyStr>,
        ) {
            self.cached_size.dirty();
            self.repeated_string_piece = v.into_iter().collect();
        }
        pub fn repeated_cord(&self) -> RepeatedView<'_, pbrs::rt::LazyStr> {
            self.repeated_cord.as_view()
        }
        pub fn repeated_cord_mut(&mut self) -> RepeatedMut<'_, pbrs::rt::LazyStr> {
            self.cached_size.dirty();
            self.repeated_cord.as_mut()
        }
        pub fn set_repeated_cord(&mut self, v: impl IntoIterator<Item = pbrs::rt::LazyStr>) {
            self.cached_size.dirty();
            self.repeated_cord = v.into_iter().collect();
        }
        pub fn map_int32_int32(&self) -> MapView<'_, i32, i32> {
            self.map_int32_int32.as_view()
        }
        pub fn map_int32_int32_mut(&mut self) -> MapMut<'_, i32, i32> {
            self.cached_size.dirty();
            self.map_int32_int32.as_mut()
        }
        pub fn set_map_int32_int32(&mut self, v: Map<i32, i32>) {
            self.cached_size.dirty();
            self.map_int32_int32 = v;
        }
        pub fn map_int64_int64(&self) -> MapView<'_, i64, i64> {
            self.map_int64_int64.as_view()
        }
        pub fn map_int64_int64_mut(&mut self) -> MapMut<'_, i64, i64> {
            self.cached_size.dirty();
            self.map_int64_int64.as_mut()
        }
        pub fn set_map_int64_int64(&mut self, v: Map<i64, i64>) {
            self.cached_size.dirty();
            self.map_int64_int64 = v;
        }
        pub fn map_uint32_uint32(&self) -> MapView<'_, u32, u32> {
            self.map_uint32_uint32.as_view()
        }
        pub fn map_uint32_uint32_mut(&mut self) -> MapMut<'_, u32, u32> {
            self.cached_size.dirty();
            self.map_uint32_uint32.as_mut()
        }
        pub fn set_map_uint32_uint32(&mut self, v: Map<u32, u32>) {
            self.cached_size.dirty();
            self.map_uint32_uint32 = v;
        }
        pub fn map_uint64_uint64(&self) -> MapView<'_, u64, u64> {
            self.map_uint64_uint64.as_view()
        }
        pub fn map_uint64_uint64_mut(&mut self) -> MapMut<'_, u64, u64> {
            self.cached_size.dirty();
            self.map_uint64_uint64.as_mut()
        }
        pub fn set_map_uint64_uint64(&mut self, v: Map<u64, u64>) {
            self.cached_size.dirty();
            self.map_uint64_uint64 = v;
        }
        pub fn map_sint32_sint32(&self) -> MapView<'_, i32, i32> {
            self.map_sint32_sint32.as_view()
        }
        pub fn map_sint32_sint32_mut(&mut self) -> MapMut<'_, i32, i32> {
            self.cached_size.dirty();
            self.map_sint32_sint32.as_mut()
        }
        pub fn set_map_sint32_sint32(&mut self, v: Map<i32, i32>) {
            self.cached_size.dirty();
            self.map_sint32_sint32 = v;
        }
        pub fn map_sint64_sint64(&self) -> MapView<'_, i64, i64> {
            self.map_sint64_sint64.as_view()
        }
        pub fn map_sint64_sint64_mut(&mut self) -> MapMut<'_, i64, i64> {
            self.cached_size.dirty();
            self.map_sint64_sint64.as_mut()
        }
        pub fn set_map_sint64_sint64(&mut self, v: Map<i64, i64>) {
            self.cached_size.dirty();
            self.map_sint64_sint64 = v;
        }
        pub fn map_fixed32_fixed32(&self) -> MapView<'_, u32, u32> {
            self.map_fixed32_fixed32.as_view()
        }
        pub fn map_fixed32_fixed32_mut(&mut self) -> MapMut<'_, u32, u32> {
            self.cached_size.dirty();
            self.map_fixed32_fixed32.as_mut()
        }
        pub fn set_map_fixed32_fixed32(&mut self, v: Map<u32, u32>) {
            self.cached_size.dirty();
            self.map_fixed32_fixed32 = v;
        }
        pub fn map_fixed64_fixed64(&self) -> MapView<'_, u64, u64> {
            self.map_fixed64_fixed64.as_view()
        }
        pub fn map_fixed64_fixed64_mut(&mut self) -> MapMut<'_, u64, u64> {
            self.cached_size.dirty();
            self.map_fixed64_fixed64.as_mut()
        }
        pub fn set_map_fixed64_fixed64(&mut self, v: Map<u64, u64>) {
            self.cached_size.dirty();
            self.map_fixed64_fixed64 = v;
        }
        pub fn map_sfixed32_sfixed32(&self) -> MapView<'_, i32, i32> {
            self.map_sfixed32_sfixed32.as_view()
        }
        pub fn map_sfixed32_sfixed32_mut(&mut self) -> MapMut<'_, i32, i32> {
            self.cached_size.dirty();
            self.map_sfixed32_sfixed32.as_mut()
        }
        pub fn set_map_sfixed32_sfixed32(&mut self, v: Map<i32, i32>) {
            self.cached_size.dirty();
            self.map_sfixed32_sfixed32 = v;
        }
        pub fn map_sfixed64_sfixed64(&self) -> MapView<'_, i64, i64> {
            self.map_sfixed64_sfixed64.as_view()
        }
        pub fn map_sfixed64_sfixed64_mut(&mut self) -> MapMut<'_, i64, i64> {
            self.cached_size.dirty();
            self.map_sfixed64_sfixed64.as_mut()
        }
        pub fn set_map_sfixed64_sfixed64(&mut self, v: Map<i64, i64>) {
            self.cached_size.dirty();
            self.map_sfixed64_sfixed64 = v;
        }
        pub fn map_int32_float(&self) -> MapView<'_, i32, f32> {
            self.map_int32_float.as_view()
        }
        pub fn map_int32_float_mut(&mut self) -> MapMut<'_, i32, f32> {
            self.cached_size.dirty();
            self.map_int32_float.as_mut()
        }
        pub fn set_map_int32_float(&mut self, v: Map<i32, f32>) {
            self.cached_size.dirty();
            self.map_int32_float = v;
        }
        pub fn map_int32_double(&self) -> MapView<'_, i32, f64> {
            self.map_int32_double.as_view()
        }
        pub fn map_int32_double_mut(&mut self) -> MapMut<'_, i32, f64> {
            self.cached_size.dirty();
            self.map_int32_double.as_mut()
        }
        pub fn set_map_int32_double(&mut self, v: Map<i32, f64>) {
            self.cached_size.dirty();
            self.map_int32_double = v;
        }
        pub fn map_bool_bool(&self) -> MapView<'_, bool, bool> {
            self.map_bool_bool.as_view()
        }
        pub fn map_bool_bool_mut(&mut self) -> MapMut<'_, bool, bool> {
            self.cached_size.dirty();
            self.map_bool_bool.as_mut()
        }
        pub fn set_map_bool_bool(&mut self, v: Map<bool, bool>) {
            self.cached_size.dirty();
            self.map_bool_bool = v;
        }
        pub fn map_string_string(&self) -> MapView<'_, pbrs::rt::LazyStr, pbrs::rt::LazyStr> {
            self.map_string_string.as_view()
        }
        pub fn map_string_string_mut(
            &mut self,
        ) -> MapMut<'_, pbrs::rt::LazyStr, pbrs::rt::LazyStr> {
            self.cached_size.dirty();
            self.map_string_string.as_mut()
        }
        pub fn set_map_string_string(&mut self, v: Map<pbrs::rt::LazyStr, pbrs::rt::LazyStr>) {
            self.cached_size.dirty();
            self.map_string_string = v;
        }
        pub fn map_string_bytes(&self) -> MapView<'_, pbrs::rt::LazyStr, pbrs::rt::LazyBytes> {
            self.map_string_bytes.as_view()
        }
        pub fn map_string_bytes_mut(
            &mut self,
        ) -> MapMut<'_, pbrs::rt::LazyStr, pbrs::rt::LazyBytes> {
            self.cached_size.dirty();
            self.map_string_bytes.as_mut()
        }
        pub fn set_map_string_bytes(&mut self, v: Map<pbrs::rt::LazyStr, pbrs::rt::LazyBytes>) {
            self.cached_size.dirty();
            self.map_string_bytes = v;
        }
        pub fn map_string_nested_message(&self) -> MapView<'_, pbrs::rt::LazyStr, NestedMessage> {
            self.map_string_nested_message.as_view()
        }
        pub fn map_string_nested_message_mut(
            &mut self,
        ) -> MapMut<'_, pbrs::rt::LazyStr, NestedMessage> {
            self.cached_size.dirty();
            self.map_string_nested_message.as_mut()
        }
        pub fn set_map_string_nested_message(&mut self, v: Map<pbrs::rt::LazyStr, NestedMessage>) {
            self.cached_size.dirty();
            self.map_string_nested_message = v;
        }
        pub fn map_string_foreign_message(
            &self,
        ) -> MapView<'_, pbrs::rt::LazyStr, ForeignMessageEdition2023> {
            self.map_string_foreign_message.as_view()
        }
        pub fn map_string_foreign_message_mut(
            &mut self,
        ) -> MapMut<'_, pbrs::rt::LazyStr, ForeignMessageEdition2023> {
            self.cached_size.dirty();
            self.map_string_foreign_message.as_mut()
        }
        pub fn set_map_string_foreign_message(
            &mut self,
            v: Map<pbrs::rt::LazyStr, ForeignMessageEdition2023>,
        ) {
            self.cached_size.dirty();
            self.map_string_foreign_message = v;
        }
        pub fn map_string_nested_enum(&self) -> MapView<'_, pbrs::rt::LazyStr, i32> {
            self.map_string_nested_enum.as_view()
        }
        pub fn map_string_nested_enum_mut(&mut self) -> MapMut<'_, pbrs::rt::LazyStr, i32> {
            self.cached_size.dirty();
            self.map_string_nested_enum.as_mut()
        }
        pub fn set_map_string_nested_enum(&mut self, v: Map<pbrs::rt::LazyStr, i32>) {
            self.cached_size.dirty();
            self.map_string_nested_enum = v;
        }
        pub fn map_string_foreign_enum(&self) -> MapView<'_, pbrs::rt::LazyStr, i32> {
            self.map_string_foreign_enum.as_view()
        }
        pub fn map_string_foreign_enum_mut(&mut self) -> MapMut<'_, pbrs::rt::LazyStr, i32> {
            self.cached_size.dirty();
            self.map_string_foreign_enum.as_mut()
        }
        pub fn set_map_string_foreign_enum(&mut self, v: Map<pbrs::rt::LazyStr, i32>) {
            self.cached_size.dirty();
            self.map_string_foreign_enum = v;
        }
        pub fn packed_int32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.packed_int32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_int32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().packed_int32.as_mut()
        }
        pub fn set_packed_int32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().packed_int32 = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_int64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.packed_int64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_int64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().packed_int64.as_mut()
        }
        pub fn set_packed_int64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().packed_int64 = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_uint32(&self) -> RepeatedView<'_, u32> {
            self.cold
                .as_ref()
                .map(|c| c.packed_uint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_uint32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.cold_mut().packed_uint32.as_mut()
        }
        pub fn set_packed_uint32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.cold_mut().packed_uint32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_uint64(&self) -> RepeatedView<'_, u64> {
            self.cold
                .as_ref()
                .map(|c| c.packed_uint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_uint64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.cold_mut().packed_uint64.as_mut()
        }
        pub fn set_packed_uint64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.cold_mut().packed_uint64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_sint32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.packed_sint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_sint32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().packed_sint32.as_mut()
        }
        pub fn set_packed_sint32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().packed_sint32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_sint64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.packed_sint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_sint64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().packed_sint64.as_mut()
        }
        pub fn set_packed_sint64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().packed_sint64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_fixed32(&self) -> RepeatedView<'_, u32> {
            self.packed_fixed32.as_view()
        }
        pub fn packed_fixed32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.packed_fixed32.as_mut()
        }
        pub fn set_packed_fixed32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.packed_fixed32 = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_fixed64(&self) -> RepeatedView<'_, u64> {
            self.packed_fixed64.as_view()
        }
        pub fn packed_fixed64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.packed_fixed64.as_mut()
        }
        pub fn set_packed_fixed64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.packed_fixed64 = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_sfixed32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.packed_sfixed32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_sfixed32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().packed_sfixed32.as_mut()
        }
        pub fn set_packed_sfixed32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().packed_sfixed32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_sfixed64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.packed_sfixed64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_sfixed64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().packed_sfixed64.as_mut()
        }
        pub fn set_packed_sfixed64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().packed_sfixed64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_float(&self) -> RepeatedView<'_, f32> {
            self.packed_float.as_view()
        }
        pub fn packed_float_mut(&mut self) -> RepeatedMut<'_, f32> {
            self.cached_size.dirty();
            self.packed_float.as_mut()
        }
        pub fn set_packed_float(&mut self, v: impl IntoIterator<Item = f32>) {
            self.cached_size.dirty();
            self.packed_float = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_double(&self) -> RepeatedView<'_, f64> {
            self.cold
                .as_ref()
                .map(|c| c.packed_double.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_double_mut(&mut self) -> RepeatedMut<'_, f64> {
            self.cached_size.dirty();
            self.cold_mut().packed_double.as_mut()
        }
        pub fn set_packed_double(&mut self, v: impl IntoIterator<Item = f64>) {
            self.cached_size.dirty();
            self.cold_mut().packed_double =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_bool(&self) -> RepeatedView<'_, bool> {
            self.cold
                .as_ref()
                .map(|c| c.packed_bool.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_bool_mut(&mut self) -> RepeatedMut<'_, bool> {
            self.cached_size.dirty();
            self.cold_mut().packed_bool.as_mut()
        }
        pub fn set_packed_bool(&mut self, v: impl IntoIterator<Item = bool>) {
            self.cached_size.dirty();
            self.cold_mut().packed_bool = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_nested_enum(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.packed_nested_enum.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_nested_enum_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().packed_nested_enum.as_mut()
        }
        pub fn set_packed_nested_enum(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().packed_nested_enum =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn unpacked_int32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_int32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_int32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_int32.as_mut()
        }
        pub fn set_unpacked_int32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_int32 = v.into_iter().collect();
        }
        pub fn unpacked_int64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_int64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_int64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_int64.as_mut()
        }
        pub fn set_unpacked_int64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_int64 = v.into_iter().collect();
        }
        pub fn unpacked_uint32(&self) -> RepeatedView<'_, u32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_uint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_uint32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_uint32.as_mut()
        }
        pub fn set_unpacked_uint32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_uint32 = v.into_iter().collect();
        }
        pub fn unpacked_uint64(&self) -> RepeatedView<'_, u64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_uint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_uint64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_uint64.as_mut()
        }
        pub fn set_unpacked_uint64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_uint64 = v.into_iter().collect();
        }
        pub fn unpacked_sint32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_sint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_sint32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sint32.as_mut()
        }
        pub fn set_unpacked_sint32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sint32 = v.into_iter().collect();
        }
        pub fn unpacked_sint64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_sint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_sint64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sint64.as_mut()
        }
        pub fn set_unpacked_sint64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sint64 = v.into_iter().collect();
        }
        pub fn unpacked_fixed32(&self) -> RepeatedView<'_, u32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_fixed32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_fixed32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_fixed32.as_mut()
        }
        pub fn set_unpacked_fixed32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_fixed32 = v.into_iter().collect();
        }
        pub fn unpacked_fixed64(&self) -> RepeatedView<'_, u64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_fixed64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_fixed64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_fixed64.as_mut()
        }
        pub fn set_unpacked_fixed64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_fixed64 = v.into_iter().collect();
        }
        pub fn unpacked_sfixed32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_sfixed32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_sfixed32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sfixed32.as_mut()
        }
        pub fn set_unpacked_sfixed32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sfixed32 = v.into_iter().collect();
        }
        pub fn unpacked_sfixed64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_sfixed64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_sfixed64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sfixed64.as_mut()
        }
        pub fn set_unpacked_sfixed64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sfixed64 = v.into_iter().collect();
        }
        pub fn unpacked_float(&self) -> RepeatedView<'_, f32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_float.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_float_mut(&mut self) -> RepeatedMut<'_, f32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_float.as_mut()
        }
        pub fn set_unpacked_float(&mut self, v: impl IntoIterator<Item = f32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_float = v.into_iter().collect();
        }
        pub fn unpacked_double(&self) -> RepeatedView<'_, f64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_double.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_double_mut(&mut self) -> RepeatedMut<'_, f64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_double.as_mut()
        }
        pub fn set_unpacked_double(&mut self, v: impl IntoIterator<Item = f64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_double = v.into_iter().collect();
        }
        pub fn unpacked_bool(&self) -> RepeatedView<'_, bool> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_bool.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_bool_mut(&mut self) -> RepeatedMut<'_, bool> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_bool.as_mut()
        }
        pub fn set_unpacked_bool(&mut self, v: impl IntoIterator<Item = bool>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_bool = v.into_iter().collect();
        }
        pub fn unpacked_nested_enum(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_nested_enum.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_nested_enum_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_nested_enum.as_mut()
        }
        pub fn set_unpacked_nested_enum(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_nested_enum = v.into_iter().collect();
        }
        pub fn has_oneof_uint32(&self) -> bool {
            self.oneof_uint32.is_some()
        }
        pub fn oneof_uint32(&self) -> u32 {
            self.oneof_uint32.unwrap_or(0)
        }
        pub fn oneof_uint32_opt(&self) -> Option<u32> {
            self.oneof_uint32.map(|v| v)
        }
        pub fn set_oneof_uint32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.oneof_nested_message = Default::default();
            self.oneof_string = None;
            self.oneof_bytes = None;
            self.oneof_bool = pbrs::rt::OptBool::NONE;
            self.oneof_uint64 = None;
            self.oneof_float = None;
            self.oneof_double = None;
            self.oneof_enum = None;
            self.oneof_uint32 = Some(v);
        }
        pub fn clear_oneof_uint32(&mut self) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
        }
        pub fn has_oneof_nested_message(&self) -> bool {
            self.oneof_nested_message.is_some()
        }
        pub fn oneof_nested_message(&self) -> &NestedMessage {
            self.oneof_nested_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn oneof_nested_message_opt(&self) -> Option<&NestedMessage> {
            self.oneof_nested_message.as_deref()
        }
        pub fn oneof_nested_message_view(&self) -> NestedMessageView<'_> {
            NestedMessageView(self.oneof_nested_message())
        }
        pub fn set_oneof_nested_message(&mut self, v: NestedMessage) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
            self.oneof_string = None;
            self.oneof_bytes = None;
            self.oneof_bool = pbrs::rt::OptBool::NONE;
            self.oneof_uint64 = None;
            self.oneof_float = None;
            self.oneof_double = None;
            self.oneof_enum = None;
            self.oneof_nested_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn oneof_nested_message_mut(&mut self) -> &mut NestedMessage {
            self.cached_size.dirty();
            self.oneof_nested_message.get_or_insert()
        }
        pub fn clear_oneof_nested_message(&mut self) {
            self.cached_size.dirty();
            self.oneof_nested_message.clear();
        }
        pub fn has_oneof_string(&self) -> bool {
            self.oneof_string.is_some()
        }
        pub fn oneof_string(&self) -> &pbrs::ProtoStr {
            self.oneof_string
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn oneof_string_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.oneof_string.as_ref().map(|s| s.as_view())
        }
        pub fn set_oneof_string(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
            self.oneof_nested_message = Default::default();
            self.oneof_bytes = None;
            self.oneof_bool = pbrs::rt::OptBool::NONE;
            self.oneof_uint64 = None;
            self.oneof_float = None;
            self.oneof_double = None;
            self.oneof_enum = None;
            self.oneof_string = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_oneof_string(&mut self) {
            self.cached_size.dirty();
            self.oneof_string = None;
        }
        pub fn oneof_bytes(&self) -> &[u8] {
            self.oneof_bytes
                .as_ref()
                .map(|b| b.as_bytes())
                .unwrap_or(b"")
        }
        pub fn oneof_bytes_opt(&self) -> Option<&[u8]> {
            self.oneof_bytes.as_ref().map(|b| b.as_bytes())
        }
        pub fn has_oneof_bytes(&self) -> bool {
            self.oneof_bytes.is_some()
        }
        pub fn set_oneof_bytes(&mut self, v: impl pbrs::IntoProxied<ProtoBytes>) {
            self.cached_size.dirty();
            self.oneof_bytes = Some(Box::new(pbrs::rt::LazyBytes::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_oneof_bytes(&mut self) {
            self.cached_size.dirty();
            self.oneof_bytes = None;
        }
        pub fn has_oneof_bool(&self) -> bool {
            self.oneof_bool.is_some()
        }
        pub fn oneof_bool(&self) -> bool {
            self.oneof_bool.unwrap_or(false)
        }
        pub fn oneof_bool_opt(&self) -> Option<bool> {
            self.oneof_bool.get()
        }
        pub fn set_oneof_bool(&mut self, v: bool) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
            self.oneof_nested_message = Default::default();
            self.oneof_string = None;
            self.oneof_bytes = None;
            self.oneof_uint64 = None;
            self.oneof_float = None;
            self.oneof_double = None;
            self.oneof_enum = None;
            self.oneof_bool = pbrs::rt::OptBool::some(v);
        }
        pub fn clear_oneof_bool(&mut self) {
            self.cached_size.dirty();
            self.oneof_bool = pbrs::rt::OptBool::NONE;
        }
        pub fn has_oneof_uint64(&self) -> bool {
            self.oneof_uint64.is_some()
        }
        pub fn oneof_uint64(&self) -> u64 {
            self.oneof_uint64.unwrap_or(0)
        }
        pub fn oneof_uint64_opt(&self) -> Option<u64> {
            self.oneof_uint64.map(|v| v)
        }
        pub fn set_oneof_uint64(&mut self, v: u64) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
            self.oneof_nested_message = Default::default();
            self.oneof_string = None;
            self.oneof_bytes = None;
            self.oneof_bool = pbrs::rt::OptBool::NONE;
            self.oneof_float = None;
            self.oneof_double = None;
            self.oneof_enum = None;
            self.oneof_uint64 = Some(v);
        }
        pub fn clear_oneof_uint64(&mut self) {
            self.cached_size.dirty();
            self.oneof_uint64 = None;
        }
        pub fn has_oneof_float(&self) -> bool {
            self.oneof_float.is_some()
        }
        pub fn oneof_float(&self) -> f32 {
            self.oneof_float.unwrap_or(0.0)
        }
        pub fn oneof_float_opt(&self) -> Option<f32> {
            self.oneof_float.map(|v| v)
        }
        pub fn set_oneof_float(&mut self, v: f32) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
            self.oneof_nested_message = Default::default();
            self.oneof_string = None;
            self.oneof_bytes = None;
            self.oneof_bool = pbrs::rt::OptBool::NONE;
            self.oneof_uint64 = None;
            self.oneof_double = None;
            self.oneof_enum = None;
            self.oneof_float = Some(v);
        }
        pub fn clear_oneof_float(&mut self) {
            self.cached_size.dirty();
            self.oneof_float = None;
        }
        pub fn has_oneof_double(&self) -> bool {
            self.oneof_double.is_some()
        }
        pub fn oneof_double(&self) -> f64 {
            self.oneof_double.unwrap_or(0.0)
        }
        pub fn oneof_double_opt(&self) -> Option<f64> {
            self.oneof_double.map(|v| v)
        }
        pub fn set_oneof_double(&mut self, v: f64) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
            self.oneof_nested_message = Default::default();
            self.oneof_string = None;
            self.oneof_bytes = None;
            self.oneof_bool = pbrs::rt::OptBool::NONE;
            self.oneof_uint64 = None;
            self.oneof_float = None;
            self.oneof_enum = None;
            self.oneof_double = Some(v);
        }
        pub fn clear_oneof_double(&mut self) {
            self.cached_size.dirty();
            self.oneof_double = None;
        }
        pub fn has_oneof_enum(&self) -> bool {
            self.oneof_enum.is_some()
        }
        pub fn oneof_enum(&self) -> NestedEnum {
            NestedEnum(self.oneof_enum.unwrap_or(0))
        }
        pub fn oneof_enum_opt(&self) -> Option<NestedEnum> {
            self.oneof_enum.map(|v| NestedEnum(v))
        }
        pub fn set_oneof_enum(&mut self, v: impl Into<i32>) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
            self.oneof_nested_message = Default::default();
            self.oneof_string = None;
            self.oneof_bytes = None;
            self.oneof_bool = pbrs::rt::OptBool::NONE;
            self.oneof_uint64 = None;
            self.oneof_float = None;
            self.oneof_double = None;
            self.oneof_enum = Some(v.into());
        }
        pub fn clear_oneof_enum(&mut self) {
            self.cached_size.dirty();
            self.oneof_enum = None;
        }
        pub fn has_extension_int32(&self) -> bool {
            self.extension_int32.is_some()
        }
        pub fn extension_int32(&self) -> i32 {
            self.extension_int32.unwrap_or(0)
        }
        pub fn extension_int32_opt(&self) -> Option<i32> {
            self.extension_int32.map(|v| v)
        }
        pub fn set_extension_int32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.extension_int32 = Some(v);
        }
        pub fn clear_extension_int32(&mut self) {
            self.cached_size.dirty();
            self.extension_int32 = None;
        }
        pub fn has_groupliketype(&self) -> bool {
            self.groupliketype.is_some()
        }
        pub fn groupliketype(&self) -> &GroupLikeType {
            self.groupliketype
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn groupliketype_opt(&self) -> Option<&GroupLikeType> {
            self.groupliketype.as_deref()
        }
        pub fn groupliketype_view(&self) -> GroupLikeTypeView<'_> {
            GroupLikeTypeView(self.groupliketype())
        }
        pub fn set_groupliketype(&mut self, v: GroupLikeType) {
            self.cached_size.dirty();
            self.groupliketype = Some(Box::new(v));
        }
        pub fn groupliketype_mut(&mut self) -> &mut GroupLikeType {
            self.cached_size.dirty();
            self.groupliketype
                .get_or_insert_with(|| Box::new(GroupLikeType::default()))
                .as_mut()
        }
        pub fn clear_groupliketype(&mut self) {
            self.cached_size.dirty();
            self.groupliketype = None;
        }
        pub fn has_delimited_ext(&self) -> bool {
            self.delimited_ext.is_some()
        }
        pub fn delimited_ext(&self) -> &GroupLikeType {
            self.delimited_ext
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn delimited_ext_opt(&self) -> Option<&GroupLikeType> {
            self.delimited_ext.as_deref()
        }
        pub fn delimited_ext_view(&self) -> GroupLikeTypeView<'_> {
            GroupLikeTypeView(self.delimited_ext())
        }
        pub fn set_delimited_ext(&mut self, v: GroupLikeType) {
            self.cached_size.dirty();
            self.delimited_ext = Some(Box::new(v));
        }
        pub fn delimited_ext_mut(&mut self) -> &mut GroupLikeType {
            self.cached_size.dirty();
            self.delimited_ext
                .get_or_insert_with(|| Box::new(GroupLikeType::default()))
                .as_mut()
        }
        pub fn clear_delimited_ext(&mut self) {
            self.cached_size.dirty();
            self.delimited_ext = None;
        }
        pub fn has_extension_string(&self) -> bool {
            self.extension_string.is_some()
        }
        pub fn extension_string(&self) -> &pbrs::ProtoStr {
            self.extension_string
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn extension_string_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.extension_string.as_ref().map(|s| s.as_view())
        }
        pub fn set_extension_string(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.extension_string = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_extension_string(&mut self) {
            self.cached_size.dirty();
            self.extension_string = None;
        }
        pub fn extension_bytes(&self) -> &[u8] {
            self.extension_bytes
                .as_ref()
                .map(|b| b.as_bytes())
                .unwrap_or(b"")
        }
        pub fn extension_bytes_opt(&self) -> Option<&[u8]> {
            self.extension_bytes.as_ref().map(|b| b.as_bytes())
        }
        pub fn has_extension_bytes(&self) -> bool {
            self.extension_bytes.is_some()
        }
        pub fn set_extension_bytes(&mut self, v: impl pbrs::IntoProxied<ProtoBytes>) {
            self.cached_size.dirty();
            self.extension_bytes = Some(Box::new(pbrs::rt::LazyBytes::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_extension_bytes(&mut self) {
            self.cached_size.dirty();
            self.extension_bytes = None;
        }
        pub fn has_groupliketype_201(&self) -> bool {
            self.groupliketype_201.is_some()
        }
        pub fn groupliketype_201(&self) -> &TestAllTypesEdition2023GroupLikeType {
            self.groupliketype_201
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn groupliketype_201_opt(&self) -> Option<&TestAllTypesEdition2023GroupLikeType> {
            self.groupliketype_201.as_deref()
        }
        pub fn groupliketype_201_view(&self) -> TestAllTypesEdition2023GroupLikeTypeView<'_> {
            TestAllTypesEdition2023GroupLikeTypeView(self.groupliketype_201())
        }
        pub fn set_groupliketype_201(&mut self, v: TestAllTypesEdition2023GroupLikeType) {
            self.cached_size.dirty();
            self.groupliketype_201 = Some(Box::new(v));
        }
        pub fn groupliketype_201_mut(&mut self) -> &mut TestAllTypesEdition2023GroupLikeType {
            self.cached_size.dirty();
            self.groupliketype_201
                .get_or_insert_with(|| Box::new(TestAllTypesEdition2023GroupLikeType::default()))
                .as_mut()
        }
        pub fn clear_groupliketype_201(&mut self) {
            self.cached_size.dirty();
            self.groupliketype_201 = None;
        }
        pub fn has_delimited_field(&self) -> bool {
            self.delimited_field.is_some()
        }
        pub fn delimited_field(&self) -> &TestAllTypesEdition2023GroupLikeType {
            self.delimited_field
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn delimited_field_opt(&self) -> Option<&TestAllTypesEdition2023GroupLikeType> {
            self.delimited_field.as_deref()
        }
        pub fn delimited_field_view(&self) -> TestAllTypesEdition2023GroupLikeTypeView<'_> {
            TestAllTypesEdition2023GroupLikeTypeView(self.delimited_field())
        }
        pub fn set_delimited_field(&mut self, v: TestAllTypesEdition2023GroupLikeType) {
            self.cached_size.dirty();
            self.delimited_field = Some(Box::new(v));
        }
        pub fn delimited_field_mut(&mut self) -> &mut TestAllTypesEdition2023GroupLikeType {
            self.cached_size.dirty();
            self.delimited_field
                .get_or_insert_with(|| Box::new(TestAllTypesEdition2023GroupLikeType::default()))
                .as_mut()
        }
        pub fn clear_delimited_field(&mut self) {
            self.cached_size.dirty();
            self.delimited_field = None;
        }
        pub fn map_recursive(&self) -> MapView<'_, i32, TestAllTypesEdition2023> {
            self.map_recursive.as_view()
        }
        pub fn map_recursive_mut(&mut self) -> MapMut<'_, i32, TestAllTypesEdition2023> {
            self.cached_size.dirty();
            self.map_recursive.as_mut()
        }
        pub fn set_map_recursive(&mut self, v: Map<i32, TestAllTypesEdition2023>) {
            self.cached_size.dirty();
            self.map_recursive = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_int32 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    2 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_int64 = Some(pbrs::rt::decode_varint(data, pos)? as i64);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    3 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_uint32 = Some(pbrs::rt::decode_varint(data, pos)? as u32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    4 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_uint64 = Some(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    5 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_sint32 = Some(pbrs::rt::decode_zigzag32(
                                pbrs::rt::decode_varint(data, pos)?,
                            ));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    6 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_sint64 = Some(pbrs::rt::decode_zigzag64(
                                pbrs::rt::decode_varint(data, pos)?,
                            ));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    7 => match w {
                        pbrs::rt::WIRE_I32 => {
                            self.optional_fixed32 = Some(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    8 => match w {
                        pbrs::rt::WIRE_I64 => {
                            self.optional_fixed64 = Some(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    9 => match w {
                        pbrs::rt::WIRE_I32 => {
                            self.optional_sfixed32 =
                                Some(pbrs::rt::read_fixed32(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    10 => match w {
                        pbrs::rt::WIRE_I64 => {
                            self.optional_sfixed64 =
                                Some(pbrs::rt::read_fixed64(data, pos)? as i64);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    11 => match w {
                        pbrs::rt::WIRE_I32 => {
                            self.optional_float =
                                Some(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    12 => match w {
                        pbrs::rt::WIRE_I64 => {
                            self.optional_double =
                                Some(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    13 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_bool =
                                pbrs::rt::OptBool::some(pbrs::rt::decode_varint(data, pos)? != 0);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    14 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.optional_string = Some(Box::new(pbrs::rt::LazyStr::from_span(
                                pbrs::rt::Wire::ensure(wire, data),
                                s,
                                e,
                            )));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    15 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.optional_bytes = Some(Box::new(pbrs::rt::LazyBytes::from_parse_span(wire, data, s, e)));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    18 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.optional_nested_message.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.optional_nested_message.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                NestedMessage::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.optional_nested_message = pbrs::rt::LazyMsg::from_wire(
                                    pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                );
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    19 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.optional_foreign_message.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.optional_foreign_message.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                ForeignMessageEdition2023::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.optional_foreign_message = pbrs::rt::LazyMsg::from_wire(
                                    pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                );
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    21 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_nested_enum =
                                Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    22 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_foreign_enum =
                                Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    24 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.optional_string_piece =
                                Some(Box::new(pbrs::rt::LazyStr::from_span(
                                    pbrs::rt::Wire::ensure(wire, data),
                                    s,
                                    e,
                                )));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    25 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.optional_cord = Some(Box::new(pbrs::rt::LazyStr::from_span(
                                pbrs::rt::Wire::ensure(wire, data),
                                s,
                                e,
                            )));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    27 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.recursive_message.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.recursive_message.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                TestAllTypesEdition2023::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.recursive_message = pbrs::rt::LazyMsg::from_wire(
                                    pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                );
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    31 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_int32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_int32
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_int32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 31 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_int32
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    32 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_int64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_int64
                                .push(pbrs::rt::decode_varint(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_int64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 32 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_int64
                                        .push(pbrs::rt::decode_varint(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    33 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_uint32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_uint32
                                .push(pbrs::rt::decode_varint(data, pos)? as u32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_uint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 33 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_uint32
                                        .push(pbrs::rt::decode_varint(data, pos)? as u32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    34 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_uint64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_uint64
                                .push(pbrs::rt::decode_varint(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_uint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 34 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_uint64
                                        .push(pbrs::rt::decode_varint(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    35 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_sint32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_sint32
                                .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_sint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 35 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_sint32
                                        .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    36 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_sint64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_sint64
                                .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_sint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 36 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_sint64
                                        .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    37 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_fixed32
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .repeated_fixed32
                                .push(pbrs::rt::read_fixed32(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_fixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 37 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .repeated_fixed32
                                        .push(pbrs::rt::read_fixed32(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    38 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_fixed64
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .repeated_fixed64
                                .push(pbrs::rt::read_fixed64(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_fixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 38 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .repeated_fixed64
                                        .push(pbrs::rt::read_fixed64(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    39 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_sfixed32
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .repeated_sfixed32
                                .push(pbrs::rt::read_fixed32(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_sfixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 39 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .repeated_sfixed32
                                        .push(pbrs::rt::read_fixed32(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    40 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_sfixed64
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .repeated_sfixed64
                                .push(pbrs::rt::read_fixed64(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_sfixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 40 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .repeated_sfixed64
                                        .push(pbrs::rt::read_fixed64(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    41 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_float
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .repeated_float
                                .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_float.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 41 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .repeated_float
                                        .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    42 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_double
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .repeated_double
                                .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_double.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 42 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .repeated_double
                                        .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    43 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_bool
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_bool
                                .push(pbrs::rt::decode_varint(data, pos)? != 0);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_bool.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 43 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_bool
                                        .push(pbrs::rt::decode_varint(data, pos)? != 0),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    44 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.repeated_string.push(pbrs::rt::LazyStr::from_span(
                                pbrs::rt::Wire::ensure(wire, data),
                                s,
                                e,
                            ));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    45 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.repeated_bytes.push(pbrs::rt::LazyBytes::from_parse_span(wire, data, s, e));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    48 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let rest = data.len().saturating_sub(e);
                            if rest > 2 {
                                self.repeated_nested_message
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = NestedMessage::default();
                            let mut ip = 0;
                            let mut sw = None;
                            inner.merge_inner(
                                &data[s..e],
                                &mut sw,
                                &mut ip,
                                depth + 1,
                                true,
                                None,
                            )?;
                            self.repeated_nested_message.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 48 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = NestedMessage::default();
                                        let mut ip = 0;
                                        let mut sw = None;
                                        inner.merge_inner(
                                            &data[s..e],
                                            &mut sw,
                                            &mut ip,
                                            depth + 1,
                                            true,
                                            None,
                                        )?;
                                        self.repeated_nested_message.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    49 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let rest = data.len().saturating_sub(e);
                            if rest > 2 {
                                self.cold_mut()
                                    .repeated_foreign_message
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = ForeignMessageEdition2023::default();
                            let mut ip = 0;
                            let mut sw = None;
                            inner.merge_inner(
                                &data[s..e],
                                &mut sw,
                                &mut ip,
                                depth + 1,
                                true,
                                None,
                            )?;
                            self.cold_mut().repeated_foreign_message.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 49 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = ForeignMessageEdition2023::default();
                                        let mut ip = 0;
                                        let mut sw = None;
                                        inner.merge_inner(
                                            &data[s..e],
                                            &mut sw,
                                            &mut ip,
                                            depth + 1,
                                            true,
                                            None,
                                        )?;
                                        self.cold_mut().repeated_foreign_message.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    51 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_nested_enum
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_nested_enum
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_nested_enum.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 51 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_nested_enum
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    52 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_foreign_enum
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_foreign_enum
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_foreign_enum.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 52 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_foreign_enum
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    54 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.repeated_string_piece
                                .push(pbrs::rt::LazyStr::from_span(
                                    pbrs::rt::Wire::ensure(wire, data),
                                    s,
                                    e,
                                ));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    55 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.repeated_cord.push(pbrs::rt::LazyStr::from_span(
                                pbrs::rt::Wire::ensure(wire, data),
                                s,
                                e,
                            ));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    56 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_int32_int32_56(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_int32_int32.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    57 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_int64_int64_57(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_int64_int64.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    58 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_uint32_uint32_58(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_uint32_uint32.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    59 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_uint64_uint64_59(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_uint64_uint64.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    60 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_sint32_sint32_60(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_sint32_sint32.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    61 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_sint64_sint64_61(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_sint64_sint64.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    62 => {
                        match w {
                            pbrs::rt::WIRE_LEN => {
                                let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                let (kk, vv) = decode_map_entry_TestAllTypesEdition2023_map_fixed32_fixed32_62(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
                                self.map_fixed32_fixed32.push_entry(kk, vv);
                            }
                            _ => self
                                .unknown
                                .fields
                                .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                        }
                    }
                    63 => {
                        match w {
                            pbrs::rt::WIRE_LEN => {
                                let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                let (kk, vv) = decode_map_entry_TestAllTypesEdition2023_map_fixed64_fixed64_63(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
                                self.map_fixed64_fixed64.push_entry(kk, vv);
                            }
                            _ => self
                                .unknown
                                .fields
                                .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                        }
                    }
                    64 => {
                        match w {
                            pbrs::rt::WIRE_LEN => {
                                let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                let (kk, vv) = decode_map_entry_TestAllTypesEdition2023_map_sfixed32_sfixed32_64(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
                                self.map_sfixed32_sfixed32.push_entry(kk, vv);
                            }
                            _ => self
                                .unknown
                                .fields
                                .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                        }
                    }
                    65 => {
                        match w {
                            pbrs::rt::WIRE_LEN => {
                                let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                let (kk, vv) = decode_map_entry_TestAllTypesEdition2023_map_sfixed64_sfixed64_65(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
                                self.map_sfixed64_sfixed64.push_entry(kk, vv);
                            }
                            _ => self
                                .unknown
                                .fields
                                .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                        }
                    }
                    66 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_int32_float_66(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_int32_float.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    67 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_int32_double_67(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_int32_double.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    68 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_bool_bool_68(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_bool_bool.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    69 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_string_string_69(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_string_string.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    70 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_string_bytes_70(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_string_bytes.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    71 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) = decode_map_entry_TestAllTypesEdition2023_map_string_nested_message_71(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
                            self.map_string_nested_message.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    72 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) = decode_map_entry_TestAllTypesEdition2023_map_string_foreign_message_72(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
                            self.map_string_foreign_message.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    73 => {
                        match w {
                            pbrs::rt::WIRE_LEN => {
                                let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                let (kk, vv) = decode_map_entry_TestAllTypesEdition2023_map_string_nested_enum_73(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
                                self.map_string_nested_enum.push_entry(kk, vv);
                            }
                            _ => self
                                .unknown
                                .fields
                                .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                        }
                    }
                    74 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) = decode_map_entry_TestAllTypesEdition2023_map_string_foreign_enum_74(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
                            self.map_string_foreign_enum.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    75 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_int32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_int32
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_int32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 75 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_int32
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    76 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_int64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_int64
                                .push(pbrs::rt::decode_varint(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_int64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 76 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_int64
                                        .push(pbrs::rt::decode_varint(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    77 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_uint32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_uint32
                                .push(pbrs::rt::decode_varint(data, pos)? as u32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_uint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 77 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_uint32
                                        .push(pbrs::rt::decode_varint(data, pos)? as u32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    78 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_uint64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_uint64
                                .push(pbrs::rt::decode_varint(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_uint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 78 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_uint64
                                        .push(pbrs::rt::decode_varint(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    79 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_sint32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_sint32
                                .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_sint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 79 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_sint32
                                        .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    80 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_sint64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_sint64
                                .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_sint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 80 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_sint64
                                        .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    81 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.packed_fixed32
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.packed_fixed32.push(pbrs::rt::read_fixed32(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.packed_fixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 81 && w2 == pbrs::rt::WIRE_I32 => {
                                        self.packed_fixed32.push(pbrs::rt::read_fixed32(data, pos)?)
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    82 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.packed_fixed64
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.packed_fixed64.push(pbrs::rt::read_fixed64(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.packed_fixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 82 && w2 == pbrs::rt::WIRE_I64 => {
                                        self.packed_fixed64.push(pbrs::rt::read_fixed64(data, pos)?)
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    83 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_sfixed32
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .packed_sfixed32
                                .push(pbrs::rt::read_fixed32(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_sfixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 83 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .packed_sfixed32
                                        .push(pbrs::rt::read_fixed32(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    84 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_sfixed64
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .packed_sfixed64
                                .push(pbrs::rt::read_fixed64(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_sfixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 84 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .packed_sfixed64
                                        .push(pbrs::rt::read_fixed64(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    85 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.packed_float
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.packed_float
                                .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.packed_float.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 85 && w2 == pbrs::rt::WIRE_I32 => self
                                        .packed_float
                                        .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    86 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_double
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .packed_double
                                .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_double.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 86 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .packed_double
                                        .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    87 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_bool
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_bool
                                .push(pbrs::rt::decode_varint(data, pos)? != 0);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_bool.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 87 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_bool
                                        .push(pbrs::rt::decode_varint(data, pos)? != 0),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    88 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_nested_enum
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_nested_enum
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_nested_enum.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 88 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_nested_enum
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    89 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_int32
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as i32);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_int32
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_int32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 89 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_int32
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    90 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_int64
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as i64);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_int64
                                .push(pbrs::rt::decode_varint(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_int64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 90 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_int64
                                        .push(pbrs::rt::decode_varint(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    91 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_uint32
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as u32);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_uint32
                                .push(pbrs::rt::decode_varint(data, pos)? as u32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_uint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 91 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_uint32
                                        .push(pbrs::rt::decode_varint(data, pos)? as u32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    92 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_uint64
                                    .push(pbrs::rt::decode_varint(p, &mut i)?);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_uint64
                                .push(pbrs::rt::decode_varint(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_uint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 92 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_uint64
                                        .push(pbrs::rt::decode_varint(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    93 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_sint32
                                    .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                        p, &mut i,
                                    )?));
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_sint32
                                .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_sint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 93 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_sint32
                                        .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    94 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_sint64
                                    .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                        p, &mut i,
                                    )?));
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_sint64
                                .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_sint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 94 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_sint64
                                        .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    95 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_fixed32
                                    .push(pbrs::rt::read_fixed32(p, &mut i)?);
                            }
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .unpacked_fixed32
                                .push(pbrs::rt::read_fixed32(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_fixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 95 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .unpacked_fixed32
                                        .push(pbrs::rt::read_fixed32(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    96 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_fixed64
                                    .push(pbrs::rt::read_fixed64(p, &mut i)?);
                            }
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .unpacked_fixed64
                                .push(pbrs::rt::read_fixed64(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_fixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 96 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .unpacked_fixed64
                                        .push(pbrs::rt::read_fixed64(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    97 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_sfixed32
                                    .push(pbrs::rt::read_fixed32(p, &mut i)? as i32);
                            }
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .unpacked_sfixed32
                                .push(pbrs::rt::read_fixed32(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_sfixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 97 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .unpacked_sfixed32
                                        .push(pbrs::rt::read_fixed32(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    98 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_sfixed64
                                    .push(pbrs::rt::read_fixed64(p, &mut i)? as i64);
                            }
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .unpacked_sfixed64
                                .push(pbrs::rt::read_fixed64(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_sfixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 98 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .unpacked_sfixed64
                                        .push(pbrs::rt::read_fixed64(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    99 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_float
                                    .push(f32::from_bits(pbrs::rt::read_fixed32(p, &mut i)?));
                            }
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .unpacked_float
                                .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_float.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 99 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .unpacked_float
                                        .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    100 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_double
                                    .push(f64::from_bits(pbrs::rt::read_fixed64(p, &mut i)?));
                            }
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .unpacked_double
                                .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_double.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 100 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .unpacked_double
                                        .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    101 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_bool
                                    .push(pbrs::rt::decode_varint(p, &mut i)? != 0);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_bool
                                .push(pbrs::rt::decode_varint(data, pos)? != 0);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_bool.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 101 && w2 == pbrs::rt::WIRE_VARINT => {
                                        self.cold_mut()
                                            .unpacked_bool
                                            .push(pbrs::rt::decode_varint(data, pos)? != 0)
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    102 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_nested_enum
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as i32);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_nested_enum
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_nested_enum.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 102 && w2 == pbrs::rt::WIRE_VARINT => {
                                        self.cold_mut()
                                            .unpacked_nested_enum
                                            .push(pbrs::rt::decode_varint(data, pos)? as i32)
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    111 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.oneof_nested_message = Default::default();
                            self.oneof_string = None;
                            self.oneof_bytes = None;
                            self.oneof_bool = pbrs::rt::OptBool::NONE;
                            self.oneof_uint64 = None;
                            self.oneof_float = None;
                            self.oneof_double = None;
                            self.oneof_enum = None;
                            self.oneof_uint32 = Some(pbrs::rt::decode_varint(data, pos)? as u32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    112 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.oneof_uint32 = None;
                            self.oneof_string = None;
                            self.oneof_bytes = None;
                            self.oneof_bool = pbrs::rt::OptBool::NONE;
                            self.oneof_uint64 = None;
                            self.oneof_float = None;
                            self.oneof_double = None;
                            self.oneof_enum = None;
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.oneof_nested_message.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.oneof_nested_message.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                NestedMessage::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.oneof_nested_message = pbrs::rt::LazyMsg::from_wire(
                                    pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                );
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    113 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.oneof_uint32 = None;
                            self.oneof_nested_message = Default::default();
                            self.oneof_bytes = None;
                            self.oneof_bool = pbrs::rt::OptBool::NONE;
                            self.oneof_uint64 = None;
                            self.oneof_float = None;
                            self.oneof_double = None;
                            self.oneof_enum = None;
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.oneof_string = Some(Box::new(pbrs::rt::LazyStr::from_span(
                                pbrs::rt::Wire::ensure(wire, data),
                                s,
                                e,
                            )));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    114 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.oneof_uint32 = None;
                            self.oneof_nested_message = Default::default();
                            self.oneof_string = None;
                            self.oneof_bool = pbrs::rt::OptBool::NONE;
                            self.oneof_uint64 = None;
                            self.oneof_float = None;
                            self.oneof_double = None;
                            self.oneof_enum = None;
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.oneof_bytes = Some(Box::new(pbrs::rt::LazyBytes::from_parse_span(wire, data, s, e)));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    115 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.oneof_uint32 = None;
                            self.oneof_nested_message = Default::default();
                            self.oneof_string = None;
                            self.oneof_bytes = None;
                            self.oneof_uint64 = None;
                            self.oneof_float = None;
                            self.oneof_double = None;
                            self.oneof_enum = None;
                            self.oneof_bool =
                                pbrs::rt::OptBool::some(pbrs::rt::decode_varint(data, pos)? != 0);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    116 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.oneof_uint32 = None;
                            self.oneof_nested_message = Default::default();
                            self.oneof_string = None;
                            self.oneof_bytes = None;
                            self.oneof_bool = pbrs::rt::OptBool::NONE;
                            self.oneof_float = None;
                            self.oneof_double = None;
                            self.oneof_enum = None;
                            self.oneof_uint64 = Some(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    117 => match w {
                        pbrs::rt::WIRE_I32 => {
                            self.oneof_uint32 = None;
                            self.oneof_nested_message = Default::default();
                            self.oneof_string = None;
                            self.oneof_bytes = None;
                            self.oneof_bool = pbrs::rt::OptBool::NONE;
                            self.oneof_uint64 = None;
                            self.oneof_double = None;
                            self.oneof_enum = None;
                            self.oneof_float =
                                Some(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    118 => match w {
                        pbrs::rt::WIRE_I64 => {
                            self.oneof_uint32 = None;
                            self.oneof_nested_message = Default::default();
                            self.oneof_string = None;
                            self.oneof_bytes = None;
                            self.oneof_bool = pbrs::rt::OptBool::NONE;
                            self.oneof_uint64 = None;
                            self.oneof_float = None;
                            self.oneof_enum = None;
                            self.oneof_double =
                                Some(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    119 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.oneof_uint32 = None;
                            self.oneof_nested_message = Default::default();
                            self.oneof_string = None;
                            self.oneof_bytes = None;
                            self.oneof_bool = pbrs::rt::OptBool::NONE;
                            self.oneof_uint64 = None;
                            self.oneof_float = None;
                            self.oneof_double = None;
                            self.oneof_enum = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    120 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.extension_int32 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    121 => match w {
                        pbrs::rt::WIRE_SGROUP => match &mut self.groupliketype {
                            Some(existing) => {
                                existing.merge_group(data, wire, pos, 121, depth + 1)?
                            }
                            None => {
                                let mut inner = GroupLikeType::default();
                                inner.merge_group(data, wire, pos, 121, depth + 1)?;
                                self.groupliketype = Some(Box::new(inner));
                            }
                        },
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    122 => match w {
                        pbrs::rt::WIRE_SGROUP => match &mut self.delimited_ext {
                            Some(existing) => {
                                existing.merge_group(data, wire, pos, 122, depth + 1)?
                            }
                            None => {
                                let mut inner = GroupLikeType::default();
                                inner.merge_group(data, wire, pos, 122, depth + 1)?;
                                self.delimited_ext = Some(Box::new(inner));
                            }
                        },
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    133 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.extension_string = Some(Box::new(pbrs::rt::LazyStr::from_span(
                                pbrs::rt::Wire::ensure(wire, data),
                                s,
                                e,
                            )));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    134 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.extension_bytes = Some(Box::new(pbrs::rt::LazyBytes::from_parse_span(wire, data, s, e)));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    201 => match w {
                        pbrs::rt::WIRE_SGROUP => match &mut self.groupliketype_201 {
                            Some(existing) => {
                                existing.merge_group(data, wire, pos, 201, depth + 1)?
                            }
                            None => {
                                let mut inner = TestAllTypesEdition2023GroupLikeType::default();
                                inner.merge_group(data, wire, pos, 201, depth + 1)?;
                                self.groupliketype_201 = Some(Box::new(inner));
                            }
                        },
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    202 => match w {
                        pbrs::rt::WIRE_SGROUP => match &mut self.delimited_field {
                            Some(existing) => {
                                existing.merge_group(data, wire, pos, 202, depth + 1)?
                            }
                            None => {
                                let mut inner = TestAllTypesEdition2023GroupLikeType::default();
                                inner.merge_group(data, wire, pos, 202, depth + 1)?;
                                self.delimited_field = Some(Box::new(inner));
                            }
                        },
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    301 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) =
                                decode_map_entry_TestAllTypesEdition2023_map_recursive_301(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_recursive.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    _ => self
                        .unknown
                        .fields
                        .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            if enforce {
                self.check_required()?;
            }
            Ok(())
        }
        fn validate_inner(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
        ) -> Result<(), ParseError> {
            Self::validate_until(wire, pos, depth, None)
        }
        fn validate_until(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let data = wire.as_slice();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    2 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    3 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    4 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    5 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    6 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    7 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    8 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    9 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    10 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    11 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    12 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    13 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    14 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    15 => match w {
                        pbrs::rt::WIRE_LEN => {
                            pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    18 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            NestedMessage::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    19 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            ForeignMessageEdition2023::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    21 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    22 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    24 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    25 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    27 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            TestAllTypesEdition2023::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    31 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    32 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    33 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    34 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    35 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    36 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    37 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    38 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    39 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    40 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    41 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    42 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    43 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedBool::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    44 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    45 => match w {
                        pbrs::rt::WIRE_LEN => {
                            pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    48 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            NestedMessage::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    49 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            ForeignMessageEdition2023::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    51 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    52 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    54 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    55 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    56 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    57 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    58 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    59 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    60 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    61 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    62 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    63 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    64 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    65 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    66 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    67 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    68 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    69 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    70 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    71 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    72 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    73 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    74 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    75 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    76 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    77 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    78 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    79 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    80 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    81 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    82 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    83 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    84 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    85 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    86 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    87 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedBool::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    88 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    89 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    90 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    91 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    92 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    93 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    94 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    95 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    96 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    97 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    98 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    99 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    100 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    101 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedBool::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    102 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    111 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    112 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            NestedMessage::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    113 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    114 => match w {
                        pbrs::rt::WIRE_LEN => {
                            pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    115 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    116 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    117 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    118 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    119 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    120 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    121 => match w {
                        pbrs::rt::WIRE_SGROUP => {
                            GroupLikeType::validate_until(wire, pos, depth + 1, Some(121))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    122 => match w {
                        pbrs::rt::WIRE_SGROUP => {
                            GroupLikeType::validate_until(wire, pos, depth + 1, Some(122))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    133 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    134 => match w {
                        pbrs::rt::WIRE_LEN => {
                            pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    201 => match w {
                        pbrs::rt::WIRE_SGROUP => {
                            TestAllTypesEdition2023GroupLikeType::validate_until(
                                wire,
                                pos,
                                depth + 1,
                                Some(201),
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    202 => match w {
                        pbrs::rt::WIRE_SGROUP => {
                            TestAllTypesEdition2023GroupLikeType::validate_until(
                                wire,
                                pos,
                                depth + 1,
                                Some(202),
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    301 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    _ => pbrs::rt::skip_field(data, pos, w)?,
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            Ok(())
        }
        fn compute_size(&self) -> u64 {
            if let Some(n) = self.cached_size.get() {
                return n;
            }
            let mut n = self.unknown.encoded_len();
            if let Some(v) = self.optional_int32 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.optional_int64 {
                n += pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.optional_uint32 {
                n += pbrs::rt::tag_len(3, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.optional_uint64 {
                n += pbrs::rt::tag_len(4, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.optional_sint32 {
                n += pbrs::rt::tag_len(5, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(v));
            }
            if let Some(v) = self.optional_sint64 {
                n += pbrs::rt::tag_len(6, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(v));
            }
            if let Some(v) = self.optional_fixed32 {
                n += pbrs::rt::tag_len(7, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.optional_fixed64 {
                n += pbrs::rt::tag_len(8, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.optional_sfixed32 {
                n += pbrs::rt::tag_len(9, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.optional_sfixed64 {
                n += pbrs::rt::tag_len(10, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.optional_float {
                n += pbrs::rt::tag_len(11, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.optional_double {
                n += pbrs::rt::tag_len(12, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.optional_bool.get() {
                n += pbrs::rt::tag_len(13, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(u64::from(v));
            }
            if let Some(s) = &self.optional_string {
                n += pbrs::rt::key_len_value_len(14, s.as_bytes().len() as u64);
            }
            if let Some(s) = &self.optional_bytes {
                n += pbrs::rt::key_len_value_len(15, s.as_bytes().len() as u64);
            }
            if let Some(p) = self.optional_nested_message.wire_bytes() {
                n += pbrs::rt::key_len_value_len(18, p.len() as u64);
            } else if let Some(m) = self.optional_nested_message.as_deref() {
                n += pbrs::rt::key_len_value_len(18, m.compute_size());
            }
            if let Some(p) = self.optional_foreign_message.wire_bytes() {
                n += pbrs::rt::key_len_value_len(19, p.len() as u64);
            } else if let Some(m) = self.optional_foreign_message.as_deref() {
                n += pbrs::rt::key_len_value_len(19, m.compute_size());
            }
            if let Some(v) = self.optional_nested_enum {
                n +=
                    pbrs::rt::tag_len(21, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.optional_foreign_enum {
                n +=
                    pbrs::rt::tag_len(22, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(s) = &self.optional_string_piece {
                n += pbrs::rt::key_len_value_len(24, s.as_bytes().len() as u64);
            }
            if let Some(s) = &self.optional_cord {
                n += pbrs::rt::key_len_value_len(25, s.as_bytes().len() as u64);
            }
            if let Some(p) = self.recursive_message.wire_bytes() {
                n += pbrs::rt::key_len_value_len(27, p.len() as u64);
            } else if let Some(m) = self.recursive_message.as_deref() {
                n += pbrs::rt::key_len_value_len(27, m.compute_size());
            }
            for t in self.repeated_string.iter() {
                n += pbrs::rt::key_len_value_len(44, t.as_bytes().len() as u64);
            }
            for t in self.repeated_bytes.iter() {
                n += pbrs::rt::key_len_value_len(45, t.as_bytes().len() as u64);
            }
            for t in self.repeated_nested_message.iter() {
                n += pbrs::rt::key_len_value_len(48, t.compute_size());
            }
            for t in self.repeated_string_piece.iter() {
                n += pbrs::rt::key_len_value_len(54, t.as_bytes().len() as u64);
            }
            for t in self.repeated_cord.iter() {
                n += pbrs::rt::key_len_value_len(55, t.as_bytes().len() as u64);
            }
            if !self.map_int32_int32.is_empty() {
                for (k, v) in self.map_int32_int32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    n += pbrs::rt::key_len_value_len(56, inner);
                }
            }
            if !self.map_int64_int64.is_empty() {
                for (k, v) in self.map_int64_int64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    n += pbrs::rt::key_len_value_len(57, inner);
                }
            }
            if !self.map_uint32_uint32.is_empty() {
                for (k, v) in self.map_uint32_uint32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*v));
                    n += pbrs::rt::key_len_value_len(58, inner);
                }
            }
            if !self.map_uint64_uint64.is_empty() {
                for (k, v) in self.map_uint64_uint64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(*k)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(*v);
                    n += pbrs::rt::key_len_value_len(59, inner);
                }
            }
            if !self.map_sint32_sint32.is_empty() {
                for (k, v) in self.map_sint32_sint32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*v));
                    n += pbrs::rt::key_len_value_len(60, inner);
                }
            }
            if !self.map_sint64_sint64.is_empty() {
                for (k, v) in self.map_sint64_sint64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*v));
                    n += pbrs::rt::key_len_value_len(61, inner);
                }
            }
            if !self.map_fixed32_fixed32.is_empty() {
                for (k, v) in self.map_fixed32_fixed32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32)
                        + 4
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    n += pbrs::rt::key_len_value_len(62, inner);
                }
            }
            if !self.map_fixed64_fixed64.is_empty() {
                for (k, v) in self.map_fixed64_fixed64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I64)
                        + 8
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    n += pbrs::rt::key_len_value_len(63, inner);
                }
            }
            if !self.map_sfixed32_sfixed32.is_empty() {
                for (k, v) in self.map_sfixed32_sfixed32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32)
                        + 4
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    n += pbrs::rt::key_len_value_len(64, inner);
                }
            }
            if !self.map_sfixed64_sfixed64.is_empty() {
                for (k, v) in self.map_sfixed64_sfixed64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I64)
                        + 8
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    n += pbrs::rt::key_len_value_len(65, inner);
                }
            }
            if !self.map_int32_float.is_empty() {
                for (k, v) in self.map_int32_float.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    n += pbrs::rt::key_len_value_len(66, inner);
                }
            }
            if !self.map_int32_double.is_empty() {
                for (k, v) in self.map_int32_double.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    n += pbrs::rt::key_len_value_len(67, inner);
                }
            }
            if !self.map_bool_bool.is_empty() {
                for (k, v) in self.map_bool_bool.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*v));
                    n += pbrs::rt::key_len_value_len(68, inner);
                }
            }
            if !self.map_string_string.is_empty() {
                for (k, v) in self.map_string_string.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
                    n += pbrs::rt::key_len_value_len(69, inner);
                }
            }
            if !self.map_string_bytes.is_empty() {
                for (k, v) in self.map_string_bytes.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
                    n += pbrs::rt::key_len_value_len(70, inner);
                }
            }
            if !self.map_string_nested_message.is_empty() {
                for (k, v) in self.map_string_nested_message.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.compute_size());
                    n += pbrs::rt::key_len_value_len(71, inner);
                }
            }
            if !self.map_string_foreign_message.is_empty() {
                for (k, v) in self.map_string_foreign_message.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.compute_size());
                    n += pbrs::rt::key_len_value_len(72, inner);
                }
            }
            if !self.map_string_nested_enum.is_empty() {
                for (k, v) in self.map_string_nested_enum.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    n += pbrs::rt::key_len_value_len(73, inner);
                }
            }
            if !self.map_string_foreign_enum.is_empty() {
                for (k, v) in self.map_string_foreign_enum.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    n += pbrs::rt::key_len_value_len(74, inner);
                }
            }
            if let Some(p) = self.packed_fixed32.packed_bytes() {
                n += pbrs::rt::key_len_value_len(81, p.len() as u64);
            } else if !self.packed_fixed32.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_fixed32.iter() {
                    payload += 4;
                }
                n += pbrs::rt::key_len_value_len(81, payload);
            }
            if let Some(p) = self.packed_fixed64.packed_bytes() {
                n += pbrs::rt::key_len_value_len(82, p.len() as u64);
            } else if !self.packed_fixed64.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_fixed64.iter() {
                    payload += 8;
                }
                n += pbrs::rt::key_len_value_len(82, payload);
            }
            if let Some(p) = self.packed_float.packed_bytes() {
                n += pbrs::rt::key_len_value_len(85, p.len() as u64);
            } else if !self.packed_float.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_float.iter() {
                    payload += 4;
                }
                n += pbrs::rt::key_len_value_len(85, payload);
            }
            if let Some(v) = self.oneof_uint32 {
                n += pbrs::rt::tag_len(111, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(p) = self.oneof_nested_message.wire_bytes() {
                n += pbrs::rt::key_len_value_len(112, p.len() as u64);
            } else if let Some(m) = self.oneof_nested_message.as_deref() {
                n += pbrs::rt::key_len_value_len(112, m.compute_size());
            }
            if let Some(s) = &self.oneof_string {
                n += pbrs::rt::key_len_value_len(113, s.as_bytes().len() as u64);
            }
            if let Some(s) = &self.oneof_bytes {
                n += pbrs::rt::key_len_value_len(114, s.as_bytes().len() as u64);
            }
            if let Some(v) = self.oneof_bool.get() {
                n += pbrs::rt::tag_len(115, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(u64::from(v));
            }
            if let Some(v) = self.oneof_uint64 {
                n += pbrs::rt::tag_len(116, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.oneof_float {
                n += pbrs::rt::tag_len(117, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.oneof_double {
                n += pbrs::rt::tag_len(118, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.oneof_enum {
                n += pbrs::rt::tag_len(119, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.extension_int32 {
                n += pbrs::rt::tag_len(120, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(m) = &self.groupliketype {
                n += pbrs::rt::tag_len(121, pbrs::rt::WIRE_SGROUP)
                    + m.compute_size()
                    + pbrs::rt::tag_len(121, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(m) = &self.delimited_ext {
                n += pbrs::rt::tag_len(122, pbrs::rt::WIRE_SGROUP)
                    + m.compute_size()
                    + pbrs::rt::tag_len(122, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(s) = &self.extension_string {
                n += pbrs::rt::key_len_value_len(133, s.as_bytes().len() as u64);
            }
            if let Some(s) = &self.extension_bytes {
                n += pbrs::rt::key_len_value_len(134, s.as_bytes().len() as u64);
            }
            if let Some(m) = &self.groupliketype_201 {
                n += pbrs::rt::tag_len(201, pbrs::rt::WIRE_SGROUP)
                    + m.compute_size()
                    + pbrs::rt::tag_len(201, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(m) = &self.delimited_field {
                n += pbrs::rt::tag_len(202, pbrs::rt::WIRE_SGROUP)
                    + m.compute_size()
                    + pbrs::rt::tag_len(202, pbrs::rt::WIRE_EGROUP);
            }
            if !self.map_recursive.is_empty() {
                for (k, v) in self.map_recursive.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::key_len_value_len(2, v.compute_size());
                    n += pbrs::rt::key_len_value_len(301, inner);
                }
            }
            if let Some(c) = self.cold.as_deref() {
                if let Some(p) = c.repeated_int32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(31, p.len() as u64);
                } else if !c.repeated_int32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_int32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(31, payload);
                }
                if let Some(p) = c.repeated_int64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(32, p.len() as u64);
                } else if !c.repeated_int64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_int64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(32, payload);
                }
                if let Some(p) = c.repeated_uint32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(33, p.len() as u64);
                } else if !c.repeated_uint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_uint32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(33, payload);
                }
                if let Some(p) = c.repeated_uint64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(34, p.len() as u64);
                } else if !c.repeated_uint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_uint64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(34, payload);
                }
                if let Some(p) = c.repeated_sint32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(35, p.len() as u64);
                } else if !c.repeated_sint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sint32.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*t));
                    }
                    n += pbrs::rt::key_len_value_len(35, payload);
                }
                if let Some(p) = c.repeated_sint64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(36, p.len() as u64);
                } else if !c.repeated_sint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sint64.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*t));
                    }
                    n += pbrs::rt::key_len_value_len(36, payload);
                }
                if let Some(p) = c.repeated_fixed32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(37, p.len() as u64);
                } else if !c.repeated_fixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_fixed32.iter() {
                        payload += 4;
                    }
                    n += pbrs::rt::key_len_value_len(37, payload);
                }
                if let Some(p) = c.repeated_fixed64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(38, p.len() as u64);
                } else if !c.repeated_fixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_fixed64.iter() {
                        payload += 8;
                    }
                    n += pbrs::rt::key_len_value_len(38, payload);
                }
                if let Some(p) = c.repeated_sfixed32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(39, p.len() as u64);
                } else if !c.repeated_sfixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sfixed32.iter() {
                        payload += 4;
                    }
                    n += pbrs::rt::key_len_value_len(39, payload);
                }
                if let Some(p) = c.repeated_sfixed64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(40, p.len() as u64);
                } else if !c.repeated_sfixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sfixed64.iter() {
                        payload += 8;
                    }
                    n += pbrs::rt::key_len_value_len(40, payload);
                }
                if let Some(p) = c.repeated_float.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(41, p.len() as u64);
                } else if !c.repeated_float.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_float.iter() {
                        payload += 4;
                    }
                    n += pbrs::rt::key_len_value_len(41, payload);
                }
                if let Some(p) = c.repeated_double.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(42, p.len() as u64);
                } else if !c.repeated_double.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_double.iter() {
                        payload += 8;
                    }
                    n += pbrs::rt::key_len_value_len(42, payload);
                }
                if let Some(p) = c.repeated_bool.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(43, p.len() as u64);
                } else if !c.repeated_bool.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_bool.iter() {
                        payload += pbrs::rt::varint_len(u64::from(*t));
                    }
                    n += pbrs::rt::key_len_value_len(43, payload);
                }
                for t in c.repeated_foreign_message.iter() {
                    n += pbrs::rt::key_len_value_len(49, t.compute_size());
                }
                if let Some(p) = c.repeated_nested_enum.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(51, p.len() as u64);
                } else if !c.repeated_nested_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_nested_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(51, payload);
                }
                if let Some(p) = c.repeated_foreign_enum.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(52, p.len() as u64);
                } else if !c.repeated_foreign_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_foreign_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(52, payload);
                }
                if let Some(p) = c.packed_int32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(75, p.len() as u64);
                } else if !c.packed_int32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_int32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(75, payload);
                }
                if let Some(p) = c.packed_int64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(76, p.len() as u64);
                } else if !c.packed_int64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_int64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(76, payload);
                }
                if let Some(p) = c.packed_uint32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(77, p.len() as u64);
                } else if !c.packed_uint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_uint32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(77, payload);
                }
                if let Some(p) = c.packed_uint64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(78, p.len() as u64);
                } else if !c.packed_uint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_uint64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(78, payload);
                }
                if let Some(p) = c.packed_sint32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(79, p.len() as u64);
                } else if !c.packed_sint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sint32.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*t));
                    }
                    n += pbrs::rt::key_len_value_len(79, payload);
                }
                if let Some(p) = c.packed_sint64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(80, p.len() as u64);
                } else if !c.packed_sint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sint64.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*t));
                    }
                    n += pbrs::rt::key_len_value_len(80, payload);
                }
                if let Some(p) = c.packed_sfixed32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(83, p.len() as u64);
                } else if !c.packed_sfixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sfixed32.iter() {
                        payload += 4;
                    }
                    n += pbrs::rt::key_len_value_len(83, payload);
                }
                if let Some(p) = c.packed_sfixed64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(84, p.len() as u64);
                } else if !c.packed_sfixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sfixed64.iter() {
                        payload += 8;
                    }
                    n += pbrs::rt::key_len_value_len(84, payload);
                }
                if let Some(p) = c.packed_double.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(86, p.len() as u64);
                } else if !c.packed_double.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_double.iter() {
                        payload += 8;
                    }
                    n += pbrs::rt::key_len_value_len(86, payload);
                }
                if let Some(p) = c.packed_bool.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(87, p.len() as u64);
                } else if !c.packed_bool.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_bool.iter() {
                        payload += pbrs::rt::varint_len(u64::from(*t));
                    }
                    n += pbrs::rt::key_len_value_len(87, payload);
                }
                if let Some(p) = c.packed_nested_enum.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(88, p.len() as u64);
                } else if !c.packed_nested_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_nested_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(88, payload);
                }
                for t in c.unpacked_int32.iter() {
                    n += pbrs::rt::tag_len(89, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.unpacked_int64.iter() {
                    n += pbrs::rt::tag_len(90, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.unpacked_uint32.iter() {
                    n += pbrs::rt::tag_len(91, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.unpacked_uint64.iter() {
                    n += pbrs::rt::tag_len(92, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.unpacked_sint32.iter() {
                    n += pbrs::rt::tag_len(93, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*t));
                }
                for t in c.unpacked_sint64.iter() {
                    n += pbrs::rt::tag_len(94, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*t));
                }
                for t in c.unpacked_fixed32.iter() {
                    n += pbrs::rt::tag_len(95, pbrs::rt::WIRE_I32) + 4;
                }
                for t in c.unpacked_fixed64.iter() {
                    n += pbrs::rt::tag_len(96, pbrs::rt::WIRE_I64) + 8;
                }
                for t in c.unpacked_sfixed32.iter() {
                    n += pbrs::rt::tag_len(97, pbrs::rt::WIRE_I32) + 4;
                }
                for t in c.unpacked_sfixed64.iter() {
                    n += pbrs::rt::tag_len(98, pbrs::rt::WIRE_I64) + 8;
                }
                for t in c.unpacked_float.iter() {
                    n += pbrs::rt::tag_len(99, pbrs::rt::WIRE_I32) + 4;
                }
                for t in c.unpacked_double.iter() {
                    n += pbrs::rt::tag_len(100, pbrs::rt::WIRE_I64) + 8;
                }
                for t in c.unpacked_bool.iter() {
                    n += pbrs::rt::tag_len(101, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*t));
                }
                for t in c.unpacked_nested_enum.iter() {
                    n += pbrs::rt::tag_len(102, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(v) = self.optional_int32 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.optional_int64 {
                pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.optional_uint32 {
                pbrs::rt::encode_tag(out, 3, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.optional_uint64 {
                pbrs::rt::encode_tag(out, 4, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.optional_sint32 {
                pbrs::rt::encode_tag(out, 5, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(v));
            }
            if let Some(v) = self.optional_sint64 {
                pbrs::rt::encode_tag(out, 6, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(v));
            }
            if let Some(v) = self.optional_fixed32 {
                pbrs::rt::encode_tag(out, 7, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(v).to_le_bytes());
            }
            if let Some(v) = self.optional_fixed64 {
                pbrs::rt::encode_tag(out, 8, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(v).to_le_bytes());
            }
            if let Some(v) = self.optional_sfixed32 {
                pbrs::rt::encode_tag(out, 9, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&((v) as u32).to_le_bytes());
            }
            if let Some(v) = self.optional_sfixed64 {
                pbrs::rt::encode_tag(out, 10, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&((v) as u64).to_le_bytes());
            }
            if let Some(v) = self.optional_float {
                pbrs::rt::encode_tag(out, 11, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(v).to_bits().to_le_bytes());
            }
            if let Some(v) = self.optional_double {
                pbrs::rt::encode_tag(out, 12, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(v).to_bits().to_le_bytes());
            }
            if let Some(v) = self.optional_bool.get() {
                pbrs::rt::encode_tag(out, 13, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, u64::from(v));
            }
            if let Some(s) = &self.optional_string {
                pbrs::rt::encode_len_field(out, 14, s.as_bytes());
            }
            if let Some(s) = &self.optional_bytes {
                pbrs::rt::encode_len_field(out, 15, s.as_bytes());
            }
            if let Some(p) = self.optional_nested_message.wire_bytes() {
                pbrs::rt::encode_len_header(out, 18, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.optional_nested_message.as_deref() {
                pbrs::rt::encode_len_header(out, 18, m.compute_size());
                m.write_to(out);
            }
            if let Some(p) = self.optional_foreign_message.wire_bytes() {
                pbrs::rt::encode_len_header(out, 19, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.optional_foreign_message.as_deref() {
                pbrs::rt::encode_len_header(out, 19, m.compute_size());
                m.write_to(out);
            }
            if let Some(v) = self.optional_nested_enum {
                pbrs::rt::encode_tag(out, 21, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.optional_foreign_enum {
                pbrs::rt::encode_tag(out, 22, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(s) = &self.optional_string_piece {
                pbrs::rt::encode_len_field(out, 24, s.as_bytes());
            }
            if let Some(s) = &self.optional_cord {
                pbrs::rt::encode_len_field(out, 25, s.as_bytes());
            }
            if let Some(p) = self.recursive_message.wire_bytes() {
                pbrs::rt::encode_len_header(out, 27, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.recursive_message.as_deref() {
                pbrs::rt::encode_len_header(out, 27, m.compute_size());
                m.write_to(out);
            }
            for t in self.repeated_string.iter() {
                pbrs::rt::encode_len_field(out, 44, t.as_bytes());
            }
            for t in self.repeated_bytes.iter() {
                pbrs::rt::encode_len_field(out, 45, t.as_bytes());
            }
            for t in self.repeated_nested_message.iter() {
                pbrs::rt::encode_len_header(out, 48, t.compute_size());
                t.write_to(out);
            }
            for t in self.repeated_string_piece.iter() {
                pbrs::rt::encode_len_field(out, 54, t.as_bytes());
            }
            for t in self.repeated_cord.iter() {
                pbrs::rt::encode_len_field(out, 55, t.as_bytes());
            }
            if !self.map_int32_int32.is_empty() {
                for (k, v) in self.map_int32_int32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    pbrs::rt::encode_tag(out, 56, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k as u64);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v as u64);
                }
            }
            if !self.map_int64_int64.is_empty() {
                for (k, v) in self.map_int64_int64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    pbrs::rt::encode_tag(out, 57, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k as u64);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v as u64);
                }
            }
            if !self.map_uint32_uint32.is_empty() {
                for (k, v) in self.map_uint32_uint32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*v));
                    pbrs::rt::encode_tag(out, 58, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k as u64);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v as u64);
                }
            }
            if !self.map_uint64_uint64.is_empty() {
                for (k, v) in self.map_uint64_uint64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(*k)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(*v);
                    pbrs::rt::encode_tag(out, 59, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v);
                }
            }
            if !self.map_sint32_sint32.is_empty() {
                for (k, v) in self.map_sint32_sint32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*v));
                    pbrs::rt::encode_tag(out, 60, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(*k));
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(*v));
                }
            }
            if !self.map_sint64_sint64.is_empty() {
                for (k, v) in self.map_sint64_sint64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*v));
                    pbrs::rt::encode_tag(out, 61, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(*k));
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(*v));
                }
            }
            if !self.map_fixed32_fixed32.is_empty() {
                for (k, v) in self.map_fixed32_fixed32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32)
                        + 4
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    pbrs::rt::encode_tag(out, 62, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I32);
                    out.extend_from_slice(&k.to_le_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I32);
                    out.extend_from_slice(&v.to_le_bytes());
                }
            }
            if !self.map_fixed64_fixed64.is_empty() {
                for (k, v) in self.map_fixed64_fixed64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I64)
                        + 8
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    pbrs::rt::encode_tag(out, 63, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I64);
                    out.extend_from_slice(&k.to_le_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I64);
                    out.extend_from_slice(&v.to_le_bytes());
                }
            }
            if !self.map_sfixed32_sfixed32.is_empty() {
                for (k, v) in self.map_sfixed32_sfixed32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32)
                        + 4
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    pbrs::rt::encode_tag(out, 64, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I32);
                    out.extend_from_slice(&(*k as u32).to_le_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I32);
                    out.extend_from_slice(&(*v as u32).to_le_bytes());
                }
            }
            if !self.map_sfixed64_sfixed64.is_empty() {
                for (k, v) in self.map_sfixed64_sfixed64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I64)
                        + 8
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    pbrs::rt::encode_tag(out, 65, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I64);
                    out.extend_from_slice(&(*k as u64).to_le_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I64);
                    out.extend_from_slice(&(*v as u64).to_le_bytes());
                }
            }
            if !self.map_int32_float.is_empty() {
                for (k, v) in self.map_int32_float.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    pbrs::rt::encode_tag(out, 66, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k as u64);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I32);
                    out.extend_from_slice(&v.to_bits().to_le_bytes());
                }
            }
            if !self.map_int32_double.is_empty() {
                for (k, v) in self.map_int32_double.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    pbrs::rt::encode_tag(out, 67, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k as u64);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I64);
                    out.extend_from_slice(&v.to_bits().to_le_bytes());
                }
            }
            if !self.map_bool_bool.is_empty() {
                for (k, v) in self.map_bool_bool.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*v));
                    pbrs::rt::encode_tag(out, 68, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, u64::from(*k));
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, u64::from(*v));
                }
            }
            if !self.map_string_string.is_empty() {
                for (k, v) in self.map_string_string.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
                    pbrs::rt::encode_tag(out, 69, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_len_field(out, 2, v.as_bytes());
                }
            }
            if !self.map_string_bytes.is_empty() {
                for (k, v) in self.map_string_bytes.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
                    pbrs::rt::encode_tag(out, 70, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_len_field(out, 2, v.as_bytes());
                }
            }
            if !self.map_string_nested_message.is_empty() {
                for (k, v) in self.map_string_nested_message.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.compute_size());
                    pbrs::rt::encode_tag(out, 71, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_len_header(out, 2, v.compute_size());
                    v.write_to(out);
                }
            }
            if !self.map_string_foreign_message.is_empty() {
                for (k, v) in self.map_string_foreign_message.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.compute_size());
                    pbrs::rt::encode_tag(out, 72, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_len_header(out, 2, v.compute_size());
                    v.write_to(out);
                }
            }
            if !self.map_string_nested_enum.is_empty() {
                for (k, v) in self.map_string_nested_enum.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    pbrs::rt::encode_tag(out, 73, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v as u64);
                }
            }
            if !self.map_string_foreign_enum.is_empty() {
                for (k, v) in self.map_string_foreign_enum.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    pbrs::rt::encode_tag(out, 74, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v as u64);
                }
            }
            if let Some(p) = self.packed_fixed32.packed_bytes() {
                pbrs::rt::encode_len_header(out, 81, p.len() as u64);
                out.extend_from_slice(p);
            } else if !self.packed_fixed32.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_fixed32.iter() {
                    payload += 4;
                }
                pbrs::rt::encode_len_header(out, 81, payload);
                for t in self.packed_fixed32.iter() {
                    (out).extend_from_slice(&(*t).to_le_bytes());
                }
            }
            if let Some(p) = self.packed_fixed64.packed_bytes() {
                pbrs::rt::encode_len_header(out, 82, p.len() as u64);
                out.extend_from_slice(p);
            } else if !self.packed_fixed64.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_fixed64.iter() {
                    payload += 8;
                }
                pbrs::rt::encode_len_header(out, 82, payload);
                for t in self.packed_fixed64.iter() {
                    (out).extend_from_slice(&(*t).to_le_bytes());
                }
            }
            if let Some(p) = self.packed_float.packed_bytes() {
                pbrs::rt::encode_len_header(out, 85, p.len() as u64);
                out.extend_from_slice(p);
            } else if !self.packed_float.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_float.iter() {
                    payload += 4;
                }
                pbrs::rt::encode_len_header(out, 85, payload);
                for t in self.packed_float.iter() {
                    (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                }
            }
            if let Some(v) = self.oneof_uint32 {
                pbrs::rt::encode_tag(out, 111, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(p) = self.oneof_nested_message.wire_bytes() {
                pbrs::rt::encode_len_header(out, 112, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.oneof_nested_message.as_deref() {
                pbrs::rt::encode_len_header(out, 112, m.compute_size());
                m.write_to(out);
            }
            if let Some(s) = &self.oneof_string {
                pbrs::rt::encode_len_field(out, 113, s.as_bytes());
            }
            if let Some(s) = &self.oneof_bytes {
                pbrs::rt::encode_len_field(out, 114, s.as_bytes());
            }
            if let Some(v) = self.oneof_bool.get() {
                pbrs::rt::encode_tag(out, 115, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, u64::from(v));
            }
            if let Some(v) = self.oneof_uint64 {
                pbrs::rt::encode_tag(out, 116, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.oneof_float {
                pbrs::rt::encode_tag(out, 117, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(v).to_bits().to_le_bytes());
            }
            if let Some(v) = self.oneof_double {
                pbrs::rt::encode_tag(out, 118, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(v).to_bits().to_le_bytes());
            }
            if let Some(v) = self.oneof_enum {
                pbrs::rt::encode_tag(out, 119, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.extension_int32 {
                pbrs::rt::encode_tag(out, 120, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(m) = &self.groupliketype {
                pbrs::rt::encode_tag(out, 121, pbrs::rt::WIRE_SGROUP);
                m.write_to(out);
                pbrs::rt::encode_tag(out, 121, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(m) = &self.delimited_ext {
                pbrs::rt::encode_tag(out, 122, pbrs::rt::WIRE_SGROUP);
                m.write_to(out);
                pbrs::rt::encode_tag(out, 122, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(s) = &self.extension_string {
                pbrs::rt::encode_len_field(out, 133, s.as_bytes());
            }
            if let Some(s) = &self.extension_bytes {
                pbrs::rt::encode_len_field(out, 134, s.as_bytes());
            }
            if let Some(m) = &self.groupliketype_201 {
                pbrs::rt::encode_tag(out, 201, pbrs::rt::WIRE_SGROUP);
                m.write_to(out);
                pbrs::rt::encode_tag(out, 201, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(m) = &self.delimited_field {
                pbrs::rt::encode_tag(out, 202, pbrs::rt::WIRE_SGROUP);
                m.write_to(out);
                pbrs::rt::encode_tag(out, 202, pbrs::rt::WIRE_EGROUP);
            }
            if !self.map_recursive.is_empty() {
                for (k, v) in self.map_recursive.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::key_len_value_len(2, v.compute_size());
                    pbrs::rt::encode_tag(out, 301, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k as u64);
                    pbrs::rt::encode_len_header(out, 2, v.compute_size());
                    v.write_to(out);
                }
            }
            if let Some(c) = self.cold.as_deref() {
                if let Some(p) = c.repeated_int32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 31, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_int32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_int32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 31, payload);
                    for t in c.repeated_int32.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.repeated_int64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 32, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_int64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_int64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 32, payload);
                    for t in c.repeated_int64.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.repeated_uint32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 33, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_uint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_uint32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 33, payload);
                    for t in c.repeated_uint32.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.repeated_uint64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 34, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_uint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_uint64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 34, payload);
                    for t in c.repeated_uint64.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.repeated_sint32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 35, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_sint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sint32.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*t));
                    }
                    pbrs::rt::encode_len_header(out, 35, payload);
                    for t in c.repeated_sint32.iter() {
                        pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(*t));
                    }
                }
                if let Some(p) = c.repeated_sint64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 36, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_sint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sint64.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*t));
                    }
                    pbrs::rt::encode_len_header(out, 36, payload);
                    for t in c.repeated_sint64.iter() {
                        pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(*t));
                    }
                }
                if let Some(p) = c.repeated_fixed32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 37, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_fixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_fixed32.iter() {
                        payload += 4;
                    }
                    pbrs::rt::encode_len_header(out, 37, payload);
                    for t in c.repeated_fixed32.iter() {
                        (out).extend_from_slice(&(*t).to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_fixed64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 38, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_fixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_fixed64.iter() {
                        payload += 8;
                    }
                    pbrs::rt::encode_len_header(out, 38, payload);
                    for t in c.repeated_fixed64.iter() {
                        (out).extend_from_slice(&(*t).to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_sfixed32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 39, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_sfixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sfixed32.iter() {
                        payload += 4;
                    }
                    pbrs::rt::encode_len_header(out, 39, payload);
                    for t in c.repeated_sfixed32.iter() {
                        (out).extend_from_slice(&((*t) as u32).to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_sfixed64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 40, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_sfixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sfixed64.iter() {
                        payload += 8;
                    }
                    pbrs::rt::encode_len_header(out, 40, payload);
                    for t in c.repeated_sfixed64.iter() {
                        (out).extend_from_slice(&((*t) as u64).to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_float.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 41, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_float.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_float.iter() {
                        payload += 4;
                    }
                    pbrs::rt::encode_len_header(out, 41, payload);
                    for t in c.repeated_float.iter() {
                        (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_double.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 42, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_double.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_double.iter() {
                        payload += 8;
                    }
                    pbrs::rt::encode_len_header(out, 42, payload);
                    for t in c.repeated_double.iter() {
                        (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_bool.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 43, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_bool.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_bool.iter() {
                        payload += pbrs::rt::varint_len(u64::from(*t));
                    }
                    pbrs::rt::encode_len_header(out, 43, payload);
                    for t in c.repeated_bool.iter() {
                        pbrs::rt::encode_varint(out, u64::from(*t));
                    }
                }
                for t in c.repeated_foreign_message.iter() {
                    pbrs::rt::encode_len_header(out, 49, t.compute_size());
                    t.write_to(out);
                }
                if let Some(p) = c.repeated_nested_enum.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 51, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_nested_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_nested_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 51, payload);
                    for t in c.repeated_nested_enum.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.repeated_foreign_enum.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 52, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_foreign_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_foreign_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 52, payload);
                    for t in c.repeated_foreign_enum.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.packed_int32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 75, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_int32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_int32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 75, payload);
                    for t in c.packed_int32.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.packed_int64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 76, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_int64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_int64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 76, payload);
                    for t in c.packed_int64.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.packed_uint32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 77, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_uint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_uint32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 77, payload);
                    for t in c.packed_uint32.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.packed_uint64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 78, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_uint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_uint64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 78, payload);
                    for t in c.packed_uint64.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.packed_sint32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 79, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_sint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sint32.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*t));
                    }
                    pbrs::rt::encode_len_header(out, 79, payload);
                    for t in c.packed_sint32.iter() {
                        pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(*t));
                    }
                }
                if let Some(p) = c.packed_sint64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 80, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_sint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sint64.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*t));
                    }
                    pbrs::rt::encode_len_header(out, 80, payload);
                    for t in c.packed_sint64.iter() {
                        pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(*t));
                    }
                }
                if let Some(p) = c.packed_sfixed32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 83, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_sfixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sfixed32.iter() {
                        payload += 4;
                    }
                    pbrs::rt::encode_len_header(out, 83, payload);
                    for t in c.packed_sfixed32.iter() {
                        (out).extend_from_slice(&((*t) as u32).to_le_bytes());
                    }
                }
                if let Some(p) = c.packed_sfixed64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 84, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_sfixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sfixed64.iter() {
                        payload += 8;
                    }
                    pbrs::rt::encode_len_header(out, 84, payload);
                    for t in c.packed_sfixed64.iter() {
                        (out).extend_from_slice(&((*t) as u64).to_le_bytes());
                    }
                }
                if let Some(p) = c.packed_double.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 86, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_double.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_double.iter() {
                        payload += 8;
                    }
                    pbrs::rt::encode_len_header(out, 86, payload);
                    for t in c.packed_double.iter() {
                        (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                    }
                }
                if let Some(p) = c.packed_bool.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 87, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_bool.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_bool.iter() {
                        payload += pbrs::rt::varint_len(u64::from(*t));
                    }
                    pbrs::rt::encode_len_header(out, 87, payload);
                    for t in c.packed_bool.iter() {
                        pbrs::rt::encode_varint(out, u64::from(*t));
                    }
                }
                if let Some(p) = c.packed_nested_enum.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 88, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_nested_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_nested_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 88, payload);
                    for t in c.packed_nested_enum.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                for t in c.unpacked_int32.iter() {
                    pbrs::rt::encode_tag(out, 89, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.unpacked_int64.iter() {
                    pbrs::rt::encode_tag(out, 90, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.unpacked_uint32.iter() {
                    pbrs::rt::encode_tag(out, 91, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.unpacked_uint64.iter() {
                    pbrs::rt::encode_tag(out, 92, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.unpacked_sint32.iter() {
                    pbrs::rt::encode_tag(out, 93, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(*t));
                }
                for t in c.unpacked_sint64.iter() {
                    pbrs::rt::encode_tag(out, 94, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(*t));
                }
                for t in c.unpacked_fixed32.iter() {
                    pbrs::rt::encode_tag(out, 95, pbrs::rt::WIRE_I32);
                    (out).extend_from_slice(&(*t).to_le_bytes());
                }
                for t in c.unpacked_fixed64.iter() {
                    pbrs::rt::encode_tag(out, 96, pbrs::rt::WIRE_I64);
                    (out).extend_from_slice(&(*t).to_le_bytes());
                }
                for t in c.unpacked_sfixed32.iter() {
                    pbrs::rt::encode_tag(out, 97, pbrs::rt::WIRE_I32);
                    (out).extend_from_slice(&((*t) as u32).to_le_bytes());
                }
                for t in c.unpacked_sfixed64.iter() {
                    pbrs::rt::encode_tag(out, 98, pbrs::rt::WIRE_I64);
                    (out).extend_from_slice(&((*t) as u64).to_le_bytes());
                }
                for t in c.unpacked_float.iter() {
                    pbrs::rt::encode_tag(out, 99, pbrs::rt::WIRE_I32);
                    (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                }
                for t in c.unpacked_double.iter() {
                    pbrs::rt::encode_tag(out, 100, pbrs::rt::WIRE_I64);
                    (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                }
                for t in c.unpacked_bool.iter() {
                    pbrs::rt::encode_tag(out, 101, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, u64::from(*t));
                }
                for t in c.unpacked_nested_enum.iter() {
                    pbrs::rt::encode_tag(out, 102, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("json"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.TestAllTypesEdition2023")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("json"))?
                .to_json()
        }
        pub fn from_json(json: &str) -> Result<Self, ParseError> {
            Self::from_json_ignore(json, false)
        }
        pub fn from_json_ignore(json: &str, ignore: bool) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.TestAllTypesEdition2023")
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_json_with_pool(desc, Some(pool), json, ignore)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.TestAllTypesEdition2023")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text()
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.TestAllTypesEdition2023")
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text_with_unknown()
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message("protobuf_test_messages.editions.TestAllTypesEdition2023")
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_text_with_pool(desc, Some(pool), text)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
    }
    pbrs::impl_typed_message!(
        TestAllTypesEdition2023,
        TestAllTypesEdition2023View,
        TestAllTypesEdition2023Mut
    );
    fn decode_map_entry_TestAllTypesEdition2023_map_int32_int32_56(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(i32, i32), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = i32::default();
        let mut val = i32::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_VARINT) => key = pbrs::rt::decode_varint(data, &mut pos)? as i32,
                (2, pbrs::rt::WIRE_VARINT) => val = pbrs::rt::decode_varint(data, &mut pos)? as i32,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_int64_int64_57(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(i64, i64), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = i64::default();
        let mut val = i64::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_VARINT) => key = pbrs::rt::decode_varint(data, &mut pos)? as i64,
                (2, pbrs::rt::WIRE_VARINT) => val = pbrs::rt::decode_varint(data, &mut pos)? as i64,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_uint32_uint32_58(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(u32, u32), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = u32::default();
        let mut val = u32::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_VARINT) => key = pbrs::rt::decode_varint(data, &mut pos)? as u32,
                (2, pbrs::rt::WIRE_VARINT) => val = pbrs::rt::decode_varint(data, &mut pos)? as u32,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_uint64_uint64_59(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(u64, u64), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = u64::default();
        let mut val = u64::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_VARINT) => key = pbrs::rt::decode_varint(data, &mut pos)?,
                (2, pbrs::rt::WIRE_VARINT) => val = pbrs::rt::decode_varint(data, &mut pos)?,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_sint32_sint32_60(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(i32, i32), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = i32::default();
        let mut val = i32::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_VARINT) => {
                    key = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, &mut pos)?)
                }
                (2, pbrs::rt::WIRE_VARINT) => {
                    val = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, &mut pos)?)
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_sint64_sint64_61(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(i64, i64), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = i64::default();
        let mut val = i64::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_VARINT) => {
                    key = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, &mut pos)?)
                }
                (2, pbrs::rt::WIRE_VARINT) => {
                    val = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, &mut pos)?)
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_fixed32_fixed32_62(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(u32, u32), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = u32::default();
        let mut val = u32::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_I32) => key = pbrs::rt::read_fixed32(data, &mut pos)?,
                (2, pbrs::rt::WIRE_I32) => val = pbrs::rt::read_fixed32(data, &mut pos)?,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_fixed64_fixed64_63(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(u64, u64), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = u64::default();
        let mut val = u64::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_I64) => key = pbrs::rt::read_fixed64(data, &mut pos)?,
                (2, pbrs::rt::WIRE_I64) => val = pbrs::rt::read_fixed64(data, &mut pos)?,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_sfixed32_sfixed32_64(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(i32, i32), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = i32::default();
        let mut val = i32::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_I32) => key = pbrs::rt::read_fixed32(data, &mut pos)? as i32,
                (2, pbrs::rt::WIRE_I32) => val = pbrs::rt::read_fixed32(data, &mut pos)? as i32,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_sfixed64_sfixed64_65(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(i64, i64), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = i64::default();
        let mut val = i64::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_I64) => key = pbrs::rt::read_fixed64(data, &mut pos)? as i64,
                (2, pbrs::rt::WIRE_I64) => val = pbrs::rt::read_fixed64(data, &mut pos)? as i64,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_int32_float_66(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(i32, f32), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = i32::default();
        let mut val = f32::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_VARINT) => key = pbrs::rt::decode_varint(data, &mut pos)? as i32,
                (2, pbrs::rt::WIRE_I32) => {
                    val = f32::from_bits(pbrs::rt::read_fixed32(data, &mut pos)?)
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_int32_double_67(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(i32, f64), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = i32::default();
        let mut val = f64::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_VARINT) => key = pbrs::rt::decode_varint(data, &mut pos)? as i32,
                (2, pbrs::rt::WIRE_I64) => {
                    val = f64::from_bits(pbrs::rt::read_fixed64(data, &mut pos)?)
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_bool_bool_68(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(bool, bool), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = bool::default();
        let mut val = bool::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_VARINT) => key = pbrs::rt::decode_varint(data, &mut pos)? != 0,
                (2, pbrs::rt::WIRE_VARINT) => val = pbrs::rt::decode_varint(data, &mut pos)? != 0,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_string_string_69(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, pbrs::rt::LazyStr), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = pbrs::rt::LazyStr::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    val = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_string_bytes_70(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, pbrs::rt::LazyBytes), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = pbrs::rt::LazyBytes::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    val = pbrs::rt::LazyBytes::from_wire_span(wire, s, e);
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_string_nested_message_71(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, NestedMessage), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = NestedMessage::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    let mut ip = 0;
                    let mut sw = None;
                    val.merge_inner(&data[s..e], &mut sw, &mut ip, depth, true, None)?;
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_string_foreign_message_72(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, ForeignMessageEdition2023), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = ForeignMessageEdition2023::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    let mut ip = 0;
                    let mut sw = None;
                    val.merge_inner(&data[s..e], &mut sw, &mut ip, depth, true, None)?;
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_string_nested_enum_73(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, i32), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = i32::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_VARINT) => val = pbrs::rt::decode_varint(data, &mut pos)? as i32,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_string_foreign_enum_74(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, i32), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = i32::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_VARINT) => val = pbrs::rt::decode_varint(data, &mut pos)? as i32,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesEdition2023_map_recursive_301(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(i32, TestAllTypesEdition2023), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = i32::default();
        let mut val = TestAllTypesEdition2023::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_VARINT) => key = pbrs::rt::decode_varint(data, &mut pos)? as i32,
                (2, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    let mut ip = 0;
                    let mut sw = None;
                    val.merge_inner(&data[s..e], &mut sw, &mut ip, depth, true, None)?;
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    #[derive(Clone, Debug)]
    pub struct TestAllTypesEdition2023GroupLikeType {
        group_int32: Option<i32>,
        group_uint32: Option<u32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for TestAllTypesEdition2023GroupLikeType {
        fn eq(&self, other: &Self) -> bool {
            if self.group_int32 != other.group_int32 {
                return false;
            }
            if self.group_uint32 != other.group_uint32 {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for TestAllTypesEdition2023GroupLikeType {}
    impl Default for TestAllTypesEdition2023GroupLikeType {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl TestAllTypesEdition2023GroupLikeType {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.editions.TestAllTypesEdition2023.GroupLikeType";
        pub fn has_group_int32(&self) -> bool {
            self.group_int32.is_some()
        }
        pub fn group_int32(&self) -> i32 {
            self.group_int32.unwrap_or(0)
        }
        pub fn group_int32_opt(&self) -> Option<i32> {
            self.group_int32.map(|v| v)
        }
        pub fn set_group_int32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.group_int32 = Some(v);
        }
        pub fn clear_group_int32(&mut self) {
            self.cached_size.dirty();
            self.group_int32 = None;
        }
        pub fn has_group_uint32(&self) -> bool {
            self.group_uint32.is_some()
        }
        pub fn group_uint32(&self) -> u32 {
            self.group_uint32.unwrap_or(0)
        }
        pub fn group_uint32_opt(&self) -> Option<u32> {
            self.group_uint32.map(|v| v)
        }
        pub fn set_group_uint32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.group_uint32 = Some(v);
        }
        pub fn clear_group_uint32(&mut self) {
            self.cached_size.dirty();
            self.group_uint32 = None;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    202 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.group_int32 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    203 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.group_uint32 = Some(pbrs::rt::decode_varint(data, pos)? as u32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    _ => self
                        .unknown
                        .fields
                        .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            if enforce {
                self.check_required()?;
            }
            Ok(())
        }
        fn validate_inner(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
        ) -> Result<(), ParseError> {
            Self::validate_until(wire, pos, depth, None)
        }
        fn validate_until(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let data = wire.as_slice();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    202 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    203 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    _ => pbrs::rt::skip_field(data, pos, w)?,
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            Ok(())
        }
        fn compute_size(&self) -> u64 {
            if let Some(n) = self.cached_size.get() {
                return n;
            }
            let mut n = self.unknown.encoded_len();
            if let Some(v) = self.group_int32 {
                n += pbrs::rt::tag_len(202, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.group_uint32 {
                n += pbrs::rt::tag_len(203, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(v) = self.group_int32 {
                pbrs::rt::encode_tag(out, 202, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.group_uint32 {
                pbrs::rt::encode_tag(out, 203, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("json"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message(
                    "protobuf_test_messages.editions.TestAllTypesEdition2023.GroupLikeType",
                )
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("json"))?
                .to_json()
        }
        pub fn from_json(json: &str) -> Result<Self, ParseError> {
            Self::from_json_ignore(json, false)
        }
        pub fn from_json_ignore(json: &str, ignore: bool) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message(
                    "protobuf_test_messages.editions.TestAllTypesEdition2023.GroupLikeType",
                )
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_json_with_pool(desc, Some(pool), json, ignore)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message(
                    "protobuf_test_messages.editions.TestAllTypesEdition2023.GroupLikeType",
                )
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text()
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message(
                    "protobuf_test_messages.editions.TestAllTypesEdition2023.GroupLikeType",
                )
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text_with_unknown()
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message(
                    "protobuf_test_messages.editions.TestAllTypesEdition2023.GroupLikeType",
                )
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_text_with_pool(desc, Some(pool), text)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
    }
    pbrs::impl_typed_message!(
        TestAllTypesEdition2023GroupLikeType,
        TestAllTypesEdition2023GroupLikeTypeView,
        TestAllTypesEdition2023GroupLikeTypeMut
    );
    #[derive(Clone, Debug)]
    pub struct NestedMessage {
        a: Option<i32>,
        corecursive: pbrs::rt::LazyMsg<TestAllTypesEdition2023>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for NestedMessage {
        fn eq(&self, other: &Self) -> bool {
            if self.a != other.a {
                return false;
            }
            if self.corecursive != other.corecursive {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for NestedMessage {}
    impl Default for NestedMessage {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl NestedMessage {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.editions.TestAllTypesEdition2023.NestedMessage";
        pub fn has_a(&self) -> bool {
            self.a.is_some()
        }
        pub fn a(&self) -> i32 {
            self.a.unwrap_or(0)
        }
        pub fn a_opt(&self) -> Option<i32> {
            self.a.map(|v| v)
        }
        pub fn set_a(&mut self, v: i32) {
            self.cached_size.dirty();
            self.a = Some(v);
        }
        pub fn clear_a(&mut self) {
            self.cached_size.dirty();
            self.a = None;
        }
        pub fn has_corecursive(&self) -> bool {
            self.corecursive.is_some()
        }
        pub fn corecursive(&self) -> &TestAllTypesEdition2023 {
            self.corecursive
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn corecursive_opt(&self) -> Option<&TestAllTypesEdition2023> {
            self.corecursive.as_deref()
        }
        pub fn corecursive_view(&self) -> TestAllTypesEdition2023View<'_> {
            TestAllTypesEdition2023View(self.corecursive())
        }
        pub fn set_corecursive(&mut self, v: TestAllTypesEdition2023) {
            self.cached_size.dirty();
            self.corecursive = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn corecursive_mut(&mut self) -> &mut TestAllTypesEdition2023 {
            self.cached_size.dirty();
            self.corecursive.get_or_insert()
        }
        pub fn clear_corecursive(&mut self) {
            self.cached_size.dirty();
            self.corecursive.clear();
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.a = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    2 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.corecursive.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.corecursive.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                TestAllTypesEdition2023::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.corecursive = pbrs::rt::LazyMsg::from_wire(
                                    pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                );
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    _ => self
                        .unknown
                        .fields
                        .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            if enforce {
                self.check_required()?;
            }
            Ok(())
        }
        fn validate_inner(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
        ) -> Result<(), ParseError> {
            Self::validate_until(wire, pos, depth, None)
        }
        fn validate_until(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let data = wire.as_slice();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    2 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            TestAllTypesEdition2023::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    _ => pbrs::rt::skip_field(data, pos, w)?,
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            Ok(())
        }
        fn compute_size(&self) -> u64 {
            if let Some(n) = self.cached_size.get() {
                return n;
            }
            let mut n = self.unknown.encoded_len();
            if let Some(v) = self.a {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(p) = self.corecursive.wire_bytes() {
                n += pbrs::rt::key_len_value_len(2, p.len() as u64);
            } else if let Some(m) = self.corecursive.as_deref() {
                n += pbrs::rt::key_len_value_len(2, m.compute_size());
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(v) = self.a {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(p) = self.corecursive.wire_bytes() {
                pbrs::rt::encode_len_header(out, 2, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.corecursive.as_deref() {
                pbrs::rt::encode_len_header(out, 2, m.compute_size());
                m.write_to(out);
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("json"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message(
                    "protobuf_test_messages.editions.TestAllTypesEdition2023.NestedMessage",
                )
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("json"))?
                .to_json()
        }
        pub fn from_json(json: &str) -> Result<Self, ParseError> {
            Self::from_json_ignore(json, false)
        }
        pub fn from_json_ignore(json: &str, ignore: bool) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message(
                    "protobuf_test_messages.editions.TestAllTypesEdition2023.NestedMessage",
                )
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_json_with_pool(desc, Some(pool), json, ignore)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message(
                    "protobuf_test_messages.editions.TestAllTypesEdition2023.NestedMessage",
                )
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text()
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let b = pbrs::Serialize::serialize(self).map_err(|_| SerializeError::new("text"))?;
            let pool = generated_pool();
            let desc = pool
                .get_message(
                    "protobuf_test_messages.editions.TestAllTypesEdition2023.NestedMessage",
                )
                .ok_or_else(|| SerializeError::new("missing desc"))?;
            pbrs::DynamicMessage::parse_with_pool(desc, Some(pool), &b)
                .map_err(|_| SerializeError::new("text"))?
                .to_text_with_unknown()
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            let pool = generated_pool();
            let desc = pool
                .get_message(
                    "protobuf_test_messages.editions.TestAllTypesEdition2023.NestedMessage",
                )
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_text_with_pool(desc, Some(pool), text)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
    }
    pbrs::impl_typed_message!(NestedMessage, NestedMessageView, NestedMessageMut);
    pub mod test_all_types_edition2023 {
        pub use super::NestedEnum;
        pub use super::NestedMessage;
        pub use super::TestAllTypesEdition2023GroupLikeType as GroupLikeType;
    }
}
#[allow(unused_imports, reason = "generated by protoc-gen-pbrs")]
pub use __gen::*;