pbrs 0.1.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 Bool(i32);
    #[allow(non_upper_case_globals, reason = "protobuf enum names")]
    impl Bool {
        pub const Kfalse: Bool = Bool(0);
        pub const Ktrue: Bool = Bool(1);
        fn constant_name(self) -> Option<&'static str> {
            #[allow(unreachable_patterns, reason = "open enums")]
            Some(match self.0 {
                0 => "Kfalse",
                1 => "Ktrue",
                _ => return None,
            })
        }
    }
    impl From<Bool> for i32 {
        fn from(v: Bool) -> i32 {
            v.0
        }
    }
    impl TryFrom<i32> for Bool {
        type Error = UnknownEnumValue<Self>;
        fn try_from(val: i32) -> Result<Self, Self::Error> {
            if <Self as Enum>::is_known(val) {
                Ok(Self(val))
            } else {
                Err(UnknownEnumValue::new(pbrs::__internal::Private, val))
            }
        }
    }
    impl Default for Bool {
        fn default() -> Self {
            Self(0)
        }
    }
    impl std::fmt::Debug for Bool {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            if let Some(n) = self.constant_name() {
                write!(f, "Bool::{n}")
            } else {
                write!(f, "Bool::from({})", self.0)
            }
        }
    }
    impl pbrs::__internal::SealedInternal for Bool {}
    impl pbrs::Proxied for Bool {
        type View<'msg> = Bool;
    }
    impl pbrs::AsView for Bool {
        type Proxied = Self;
        fn as_view(&self) -> Self {
            *self
        }
    }
    impl<'msg> pbrs::IntoView<'msg> for Bool {
        fn into_view<'shorter>(self) -> Self
        where
            'msg: 'shorter,
        {
            self
        }
    }
    impl Enum for Bool {
        const NAME: &'static str = "Bool";
        fn is_known(value: i32) -> bool {
            matches!(value, 0 | 1)
        }
    }
    #[repr(transparent)]
    #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
    pub struct ForeignEnumProto2(i32);
    #[allow(non_upper_case_globals, reason = "protobuf enum names")]
    impl ForeignEnumProto2 {
        pub const ForeignFoo: ForeignEnumProto2 = ForeignEnumProto2(0);
        pub const ForeignBar: ForeignEnumProto2 = ForeignEnumProto2(1);
        pub const ForeignBaz: ForeignEnumProto2 = ForeignEnumProto2(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<ForeignEnumProto2> for i32 {
        fn from(v: ForeignEnumProto2) -> i32 {
            v.0
        }
    }
    impl TryFrom<i32> for ForeignEnumProto2 {
        type Error = UnknownEnumValue<Self>;
        fn try_from(val: i32) -> Result<Self, Self::Error> {
            if <Self as Enum>::is_known(val) {
                Ok(Self(val))
            } else {
                Err(UnknownEnumValue::new(pbrs::__internal::Private, val))
            }
        }
    }
    impl Default for ForeignEnumProto2 {
        fn default() -> Self {
            Self(0)
        }
    }
    impl std::fmt::Debug for ForeignEnumProto2 {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            if let Some(n) = self.constant_name() {
                write!(f, "ForeignEnumProto2::{n}")
            } else {
                write!(f, "ForeignEnumProto2::from({})", self.0)
            }
        }
    }
    impl pbrs::__internal::SealedInternal for ForeignEnumProto2 {}
    impl pbrs::Proxied for ForeignEnumProto2 {
        type View<'msg> = ForeignEnumProto2;
    }
    impl pbrs::AsView for ForeignEnumProto2 {
        type Proxied = Self;
        fn as_view(&self) -> Self {
            *self
        }
    }
    impl<'msg> pbrs::IntoView<'msg> for ForeignEnumProto2 {
        fn into_view<'shorter>(self) -> Self
        where
            'msg: 'shorter,
        {
            self
        }
    }
    impl Enum for ForeignEnumProto2 {
        const NAME: &'static str = "ForeignEnumProto2";
        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 TryFrom<i32> for NestedEnum {
        type Error = UnknownEnumValue<Self>;
        fn try_from(val: i32) -> Result<Self, Self::Error> {
            if <Self as Enum>::is_known(val) {
                Ok(Self(val))
            } else {
                Err(UnknownEnumValue::new(pbrs::__internal::Private, 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)
        }
    }
    #[repr(transparent)]
    #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
    pub struct TestAllTypesProto2NestedEnum(i32);
    #[allow(non_upper_case_globals, reason = "protobuf enum names")]
    impl TestAllTypesProto2NestedEnum {
        pub const Foo: TestAllTypesProto2NestedEnum = TestAllTypesProto2NestedEnum(0);
        pub const Bar: TestAllTypesProto2NestedEnum = TestAllTypesProto2NestedEnum(1);
        pub const Baz: TestAllTypesProto2NestedEnum = TestAllTypesProto2NestedEnum(2);
        pub const Neg: TestAllTypesProto2NestedEnum = TestAllTypesProto2NestedEnum(-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<TestAllTypesProto2NestedEnum> for i32 {
        fn from(v: TestAllTypesProto2NestedEnum) -> i32 {
            v.0
        }
    }
    impl TryFrom<i32> for TestAllTypesProto2NestedEnum {
        type Error = UnknownEnumValue<Self>;
        fn try_from(val: i32) -> Result<Self, Self::Error> {
            if <Self as Enum>::is_known(val) {
                Ok(Self(val))
            } else {
                Err(UnknownEnumValue::new(pbrs::__internal::Private, val))
            }
        }
    }
    impl Default for TestAllTypesProto2NestedEnum {
        fn default() -> Self {
            Self(0)
        }
    }
    impl std::fmt::Debug for TestAllTypesProto2NestedEnum {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            if let Some(n) = self.constant_name() {
                write!(f, "TestAllTypesProto2NestedEnum::{n}")
            } else {
                write!(f, "TestAllTypesProto2NestedEnum::from({})", self.0)
            }
        }
    }
    impl pbrs::__internal::SealedInternal for TestAllTypesProto2NestedEnum {}
    impl pbrs::Proxied for TestAllTypesProto2NestedEnum {
        type View<'msg> = TestAllTypesProto2NestedEnum;
    }
    impl pbrs::AsView for TestAllTypesProto2NestedEnum {
        type Proxied = Self;
        fn as_view(&self) -> Self {
            *self
        }
    }
    impl<'msg> pbrs::IntoView<'msg> for TestAllTypesProto2NestedEnum {
        fn into_view<'shorter>(self) -> Self
        where
            'msg: 'shorter,
        {
            self
        }
    }
    impl Enum for TestAllTypesProto2NestedEnum {
        const NAME: &'static str = "TestAllTypesProto2NestedEnum";
        fn is_known(value: i32) -> bool {
            matches!(value, 0 | 1 | 2 | -1)
        }
    }
    #[derive(Clone, Debug)]
    pub struct EnumOnlyProto2 {
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for EnumOnlyProto2 {
        fn eq(&self, other: &Self) -> bool {
            self.unknown == other.unknown
        }
    }
    impl Eq for EnumOnlyProto2 {}
    impl Default for EnumOnlyProto2 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl EnumOnlyProto2 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.EnumOnlyProto2";
        #[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 {
                    _ => 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 {
                    _ => 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();
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            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.proto2.EnumOnlyProto2")
                .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.proto2.EnumOnlyProto2")
                .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.proto2.EnumOnlyProto2")
                .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.proto2.EnumOnlyProto2")
                .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.proto2.EnumOnlyProto2")
                .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!(EnumOnlyProto2, EnumOnlyProto2View, EnumOnlyProto2Mut);
    #[derive(Clone, Debug)]
    pub struct ForeignMessageProto2 {
        c: Option<i32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for ForeignMessageProto2 {
        fn eq(&self, other: &Self) -> bool {
            if self.c != other.c {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for ForeignMessageProto2 {}
    impl Default for ForeignMessageProto2 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl ForeignMessageProto2 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.ForeignMessageProto2";
        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.proto2.ForeignMessageProto2")
                .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.proto2.ForeignMessageProto2")
                .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.proto2.ForeignMessageProto2")
                .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.proto2.ForeignMessageProto2")
                .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.proto2.ForeignMessageProto2")
                .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!(
        ForeignMessageProto2,
        ForeignMessageProto2View,
        ForeignMessageProto2Mut
    );
    #[derive(Clone, Debug)]
    pub struct GroupField {
        group_int32: Option<i32>,
        group_uint32: Option<u32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for GroupField {
        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 GroupField {}
    impl Default for GroupField {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl GroupField {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.GroupField";
        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 {
                    122 => 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)?),
                    },
                    123 => 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 {
                    122 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    123 => 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(122, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.group_uint32 {
                n += pbrs::rt::tag_len(123, 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, 122, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.group_uint32 {
                pbrs::rt::encode_tag(out, 123, 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.proto2.GroupField")
                .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.proto2.GroupField")
                .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.proto2.GroupField")
                .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.proto2.GroupField")
                .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.proto2.GroupField")
                .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!(GroupField, GroupFieldView, GroupFieldMut);
    #[derive(Clone, Debug)]
    pub struct NullHypothesisProto2 {
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for NullHypothesisProto2 {
        fn eq(&self, other: &Self) -> bool {
            self.unknown == other.unknown
        }
    }
    impl Eq for NullHypothesisProto2 {}
    impl Default for NullHypothesisProto2 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl NullHypothesisProto2 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.NullHypothesisProto2";
        #[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 {
                    _ => 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 {
                    _ => 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();
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            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.proto2.NullHypothesisProto2")
                .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.proto2.NullHypothesisProto2")
                .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.proto2.NullHypothesisProto2")
                .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.proto2.NullHypothesisProto2")
                .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.proto2.NullHypothesisProto2")
                .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!(
        NullHypothesisProto2,
        NullHypothesisProto2View,
        NullHypothesisProto2Mut
    );
    #[derive(Clone, Debug)]
    pub struct OneStringProto2 {
        data: Option<Box<pbrs::rt::LazyStr>>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for OneStringProto2 {
        fn eq(&self, other: &Self) -> bool {
            if self.data != other.data {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for OneStringProto2 {}
    impl Default for OneStringProto2 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl OneStringProto2 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.OneStringProto2";
        pub fn has_data(&self) -> bool {
            self.data.is_some()
        }
        pub fn data(&self) -> &pbrs::ProtoStr {
            self.data
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn data_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.data.as_ref().map(|s| s.as_view())
        }
        pub fn set_data(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.data = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_data(&mut self) {
            self.cached_size.dirty();
            self.data = 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_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            self.data = 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)?),
                    },
                    _ => 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_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => 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(s) = &self.data {
                n += pbrs::rt::key_len_value_len(1, s.as_bytes().len() as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(s) = &self.data {
                pbrs::rt::encode_len_field(out, 1, s.as_bytes());
            }
            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.proto2.OneStringProto2")
                .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.proto2.OneStringProto2")
                .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.proto2.OneStringProto2")
                .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.proto2.OneStringProto2")
                .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.proto2.OneStringProto2")
                .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!(OneStringProto2, OneStringProto2View, OneStringProto2Mut);
    #[derive(Clone, Debug)]
    pub struct ProtoWithKeywords {
        inline: Option<i32>,
        concept: Option<Box<pbrs::rt::LazyStr>>,
        requires: Repeated<pbrs::rt::LazyStr>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for ProtoWithKeywords {
        fn eq(&self, other: &Self) -> bool {
            if self.inline != other.inline {
                return false;
            }
            if self.concept != other.concept {
                return false;
            }
            if self.requires != other.requires {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for ProtoWithKeywords {}
    impl Default for ProtoWithKeywords {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl ProtoWithKeywords {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.ProtoWithKeywords";
        pub fn has_inline(&self) -> bool {
            self.inline.is_some()
        }
        pub fn inline(&self) -> i32 {
            self.inline.unwrap_or(0)
        }
        pub fn inline_opt(&self) -> Option<i32> {
            self.inline.map(|v| v)
        }
        pub fn set_inline(&mut self, v: i32) {
            self.cached_size.dirty();
            self.inline = Some(v);
        }
        pub fn clear_inline(&mut self) {
            self.cached_size.dirty();
            self.inline = None;
        }
        pub fn has_concept(&self) -> bool {
            self.concept.is_some()
        }
        pub fn concept(&self) -> &pbrs::ProtoStr {
            self.concept
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn concept_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.concept.as_ref().map(|s| s.as_view())
        }
        pub fn set_concept(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.concept = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_concept(&mut self) {
            self.cached_size.dirty();
            self.concept = None;
        }
        pub fn requires(&self) -> RepeatedView<'_, pbrs::rt::LazyStr> {
            self.requires.as_view()
        }
        pub fn requires_mut(&mut self) -> RepeatedMut<'_, pbrs::rt::LazyStr> {
            self.cached_size.dirty();
            self.requires.as_mut()
        }
        pub fn set_requires(&mut self, v: impl IntoIterator<Item = pbrs::rt::LazyStr>) {
            self.cached_size.dirty();
            self.requires = v.into_iter().collect();
        }
        #[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.inline = 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)?;
                            let b = &data[s..e];
                            self.concept = 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)?),
                    },
                    3 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            self.requires.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)?),
                    },
                    _ => 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)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    3 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => 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.inline {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(s) = &self.concept {
                n += pbrs::rt::key_len_value_len(2, s.as_bytes().len() as u64);
            }
            for t in self.requires.iter() {
                n += pbrs::rt::key_len_value_len(3, t.as_bytes().len() as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(v) = self.inline {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(s) = &self.concept {
                pbrs::rt::encode_len_field(out, 2, s.as_bytes());
            }
            for t in self.requires.iter() {
                pbrs::rt::encode_len_field(out, 3, t.as_bytes());
            }
            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.proto2.ProtoWithKeywords")
                .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.proto2.ProtoWithKeywords")
                .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.proto2.ProtoWithKeywords")
                .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.proto2.ProtoWithKeywords")
                .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.proto2.ProtoWithKeywords")
                .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!(
        ProtoWithKeywords,
        ProtoWithKeywordsView,
        ProtoWithKeywordsMut
    );
    #[derive(Clone, Debug)]
    pub struct TestAllRequiredTypesProto2 {
        required_int32: Option<i32>,
        required_int64: Option<i64>,
        required_uint32: Option<u32>,
        required_uint64: Option<u64>,
        required_sint32: Option<i32>,
        required_sint64: Option<i64>,
        required_fixed32: Option<u32>,
        required_fixed64: Option<u64>,
        required_sfixed32: Option<i32>,
        required_sfixed64: Option<i64>,
        required_float: Option<f32>,
        required_double: Option<f64>,
        required_bool: pbrs::rt::OptBool,
        required_string: Option<Box<pbrs::rt::LazyStr>>,
        required_bytes: Option<Box<pbrs::rt::LazyBytes>>,
        required_nested_message: pbrs::rt::LazyMsg<NestedMessage>,
        required_foreign_message: pbrs::rt::LazyMsg<ForeignMessageProto2>,
        required_nested_enum: Option<i32>,
        required_foreign_enum: Option<i32>,
        required_string_piece: Option<Box<pbrs::rt::LazyStr>>,
        required_cord: Option<Box<pbrs::rt::LazyStr>>,
        recursive_message: pbrs::rt::LazyMsg<TestAllRequiredTypesProto2>,
        optional_recursive_message: pbrs::rt::LazyMsg<TestAllRequiredTypesProto2>,
        data: Option<Box<Data>>,
        default_int32: Option<i32>,
        default_int64: Option<i64>,
        default_uint32: Option<u32>,
        default_uint64: Option<u64>,
        default_sint32: Option<i32>,
        default_sint64: Option<i64>,
        default_fixed32: Option<u32>,
        default_fixed64: Option<u64>,
        default_sfixed32: Option<i32>,
        default_sfixed64: Option<i64>,
        default_float: Option<f32>,
        default_double: Option<f64>,
        default_bool: pbrs::rt::OptBool,
        default_string: Option<Box<pbrs::rt::LazyStr>>,
        default_bytes: Option<Box<pbrs::rt::LazyBytes>>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for TestAllRequiredTypesProto2 {
        fn eq(&self, other: &Self) -> bool {
            if self.required_int32 != other.required_int32 {
                return false;
            }
            if self.required_int64 != other.required_int64 {
                return false;
            }
            if self.required_uint32 != other.required_uint32 {
                return false;
            }
            if self.required_uint64 != other.required_uint64 {
                return false;
            }
            if self.required_sint32 != other.required_sint32 {
                return false;
            }
            if self.required_sint64 != other.required_sint64 {
                return false;
            }
            if self.required_fixed32 != other.required_fixed32 {
                return false;
            }
            if self.required_fixed64 != other.required_fixed64 {
                return false;
            }
            if self.required_sfixed32 != other.required_sfixed32 {
                return false;
            }
            if self.required_sfixed64 != other.required_sfixed64 {
                return false;
            }
            if self.required_float != other.required_float {
                return false;
            }
            if self.required_double != other.required_double {
                return false;
            }
            if self.required_bool != other.required_bool {
                return false;
            }
            if self.required_string != other.required_string {
                return false;
            }
            if self.required_bytes != other.required_bytes {
                return false;
            }
            if self.required_nested_message != other.required_nested_message {
                return false;
            }
            if self.required_foreign_message != other.required_foreign_message {
                return false;
            }
            if self.required_nested_enum != other.required_nested_enum {
                return false;
            }
            if self.required_foreign_enum != other.required_foreign_enum {
                return false;
            }
            if self.required_string_piece != other.required_string_piece {
                return false;
            }
            if self.required_cord != other.required_cord {
                return false;
            }
            if self.recursive_message != other.recursive_message {
                return false;
            }
            if self.optional_recursive_message != other.optional_recursive_message {
                return false;
            }
            if self.data != other.data {
                return false;
            }
            if self.default_int32 != other.default_int32 {
                return false;
            }
            if self.default_int64 != other.default_int64 {
                return false;
            }
            if self.default_uint32 != other.default_uint32 {
                return false;
            }
            if self.default_uint64 != other.default_uint64 {
                return false;
            }
            if self.default_sint32 != other.default_sint32 {
                return false;
            }
            if self.default_sint64 != other.default_sint64 {
                return false;
            }
            if self.default_fixed32 != other.default_fixed32 {
                return false;
            }
            if self.default_fixed64 != other.default_fixed64 {
                return false;
            }
            if self.default_sfixed32 != other.default_sfixed32 {
                return false;
            }
            if self.default_sfixed64 != other.default_sfixed64 {
                return false;
            }
            if self.default_float != other.default_float {
                return false;
            }
            if self.default_double != other.default_double {
                return false;
            }
            if self.default_bool != other.default_bool {
                return false;
            }
            if self.default_string != other.default_string {
                return false;
            }
            if self.default_bytes != other.default_bytes {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for TestAllRequiredTypesProto2 {}
    impl Default for TestAllRequiredTypesProto2 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl TestAllRequiredTypesProto2 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = false;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllRequiredTypesProto2";
        pub fn has_required_int32(&self) -> bool {
            self.required_int32.is_some()
        }
        pub fn required_int32(&self) -> i32 {
            self.required_int32.unwrap_or(0)
        }
        pub fn required_int32_opt(&self) -> Option<i32> {
            self.required_int32.map(|v| v)
        }
        pub fn set_required_int32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.required_int32 = Some(v);
        }
        pub fn clear_required_int32(&mut self) {
            self.cached_size.dirty();
            self.required_int32 = None;
        }
        pub fn has_required_int64(&self) -> bool {
            self.required_int64.is_some()
        }
        pub fn required_int64(&self) -> i64 {
            self.required_int64.unwrap_or(0)
        }
        pub fn required_int64_opt(&self) -> Option<i64> {
            self.required_int64.map(|v| v)
        }
        pub fn set_required_int64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.required_int64 = Some(v);
        }
        pub fn clear_required_int64(&mut self) {
            self.cached_size.dirty();
            self.required_int64 = None;
        }
        pub fn has_required_uint32(&self) -> bool {
            self.required_uint32.is_some()
        }
        pub fn required_uint32(&self) -> u32 {
            self.required_uint32.unwrap_or(0)
        }
        pub fn required_uint32_opt(&self) -> Option<u32> {
            self.required_uint32.map(|v| v)
        }
        pub fn set_required_uint32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.required_uint32 = Some(v);
        }
        pub fn clear_required_uint32(&mut self) {
            self.cached_size.dirty();
            self.required_uint32 = None;
        }
        pub fn has_required_uint64(&self) -> bool {
            self.required_uint64.is_some()
        }
        pub fn required_uint64(&self) -> u64 {
            self.required_uint64.unwrap_or(0)
        }
        pub fn required_uint64_opt(&self) -> Option<u64> {
            self.required_uint64.map(|v| v)
        }
        pub fn set_required_uint64(&mut self, v: u64) {
            self.cached_size.dirty();
            self.required_uint64 = Some(v);
        }
        pub fn clear_required_uint64(&mut self) {
            self.cached_size.dirty();
            self.required_uint64 = None;
        }
        pub fn has_required_sint32(&self) -> bool {
            self.required_sint32.is_some()
        }
        pub fn required_sint32(&self) -> i32 {
            self.required_sint32.unwrap_or(0)
        }
        pub fn required_sint32_opt(&self) -> Option<i32> {
            self.required_sint32.map(|v| v)
        }
        pub fn set_required_sint32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.required_sint32 = Some(v);
        }
        pub fn clear_required_sint32(&mut self) {
            self.cached_size.dirty();
            self.required_sint32 = None;
        }
        pub fn has_required_sint64(&self) -> bool {
            self.required_sint64.is_some()
        }
        pub fn required_sint64(&self) -> i64 {
            self.required_sint64.unwrap_or(0)
        }
        pub fn required_sint64_opt(&self) -> Option<i64> {
            self.required_sint64.map(|v| v)
        }
        pub fn set_required_sint64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.required_sint64 = Some(v);
        }
        pub fn clear_required_sint64(&mut self) {
            self.cached_size.dirty();
            self.required_sint64 = None;
        }
        pub fn has_required_fixed32(&self) -> bool {
            self.required_fixed32.is_some()
        }
        pub fn required_fixed32(&self) -> u32 {
            self.required_fixed32.unwrap_or(0)
        }
        pub fn required_fixed32_opt(&self) -> Option<u32> {
            self.required_fixed32.map(|v| v)
        }
        pub fn set_required_fixed32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.required_fixed32 = Some(v);
        }
        pub fn clear_required_fixed32(&mut self) {
            self.cached_size.dirty();
            self.required_fixed32 = None;
        }
        pub fn has_required_fixed64(&self) -> bool {
            self.required_fixed64.is_some()
        }
        pub fn required_fixed64(&self) -> u64 {
            self.required_fixed64.unwrap_or(0)
        }
        pub fn required_fixed64_opt(&self) -> Option<u64> {
            self.required_fixed64.map(|v| v)
        }
        pub fn set_required_fixed64(&mut self, v: u64) {
            self.cached_size.dirty();
            self.required_fixed64 = Some(v);
        }
        pub fn clear_required_fixed64(&mut self) {
            self.cached_size.dirty();
            self.required_fixed64 = None;
        }
        pub fn has_required_sfixed32(&self) -> bool {
            self.required_sfixed32.is_some()
        }
        pub fn required_sfixed32(&self) -> i32 {
            self.required_sfixed32.unwrap_or(0)
        }
        pub fn required_sfixed32_opt(&self) -> Option<i32> {
            self.required_sfixed32.map(|v| v)
        }
        pub fn set_required_sfixed32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.required_sfixed32 = Some(v);
        }
        pub fn clear_required_sfixed32(&mut self) {
            self.cached_size.dirty();
            self.required_sfixed32 = None;
        }
        pub fn has_required_sfixed64(&self) -> bool {
            self.required_sfixed64.is_some()
        }
        pub fn required_sfixed64(&self) -> i64 {
            self.required_sfixed64.unwrap_or(0)
        }
        pub fn required_sfixed64_opt(&self) -> Option<i64> {
            self.required_sfixed64.map(|v| v)
        }
        pub fn set_required_sfixed64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.required_sfixed64 = Some(v);
        }
        pub fn clear_required_sfixed64(&mut self) {
            self.cached_size.dirty();
            self.required_sfixed64 = None;
        }
        pub fn has_required_float(&self) -> bool {
            self.required_float.is_some()
        }
        pub fn required_float(&self) -> f32 {
            self.required_float.unwrap_or(0.0)
        }
        pub fn required_float_opt(&self) -> Option<f32> {
            self.required_float.map(|v| v)
        }
        pub fn set_required_float(&mut self, v: f32) {
            self.cached_size.dirty();
            self.required_float = Some(v);
        }
        pub fn clear_required_float(&mut self) {
            self.cached_size.dirty();
            self.required_float = None;
        }
        pub fn has_required_double(&self) -> bool {
            self.required_double.is_some()
        }
        pub fn required_double(&self) -> f64 {
            self.required_double.unwrap_or(0.0)
        }
        pub fn required_double_opt(&self) -> Option<f64> {
            self.required_double.map(|v| v)
        }
        pub fn set_required_double(&mut self, v: f64) {
            self.cached_size.dirty();
            self.required_double = Some(v);
        }
        pub fn clear_required_double(&mut self) {
            self.cached_size.dirty();
            self.required_double = None;
        }
        pub fn has_required_bool(&self) -> bool {
            self.required_bool.is_some()
        }
        pub fn required_bool(&self) -> bool {
            self.required_bool.unwrap_or(false)
        }
        pub fn required_bool_opt(&self) -> Option<bool> {
            self.required_bool.get()
        }
        pub fn set_required_bool(&mut self, v: bool) {
            self.cached_size.dirty();
            self.required_bool = pbrs::rt::OptBool::some(v);
        }
        pub fn clear_required_bool(&mut self) {
            self.cached_size.dirty();
            self.required_bool = pbrs::rt::OptBool::NONE;
        }
        pub fn has_required_string(&self) -> bool {
            self.required_string.is_some()
        }
        pub fn required_string(&self) -> &pbrs::ProtoStr {
            self.required_string
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn required_string_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.required_string.as_ref().map(|s| s.as_view())
        }
        pub fn set_required_string(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.required_string = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_required_string(&mut self) {
            self.cached_size.dirty();
            self.required_string = None;
        }
        pub fn required_bytes(&self) -> &[u8] {
            self.required_bytes
                .as_ref()
                .map(|b| b.as_bytes())
                .unwrap_or(b"")
        }
        pub fn required_bytes_opt(&self) -> Option<&[u8]> {
            self.required_bytes.as_ref().map(|b| b.as_bytes())
        }
        pub fn has_required_bytes(&self) -> bool {
            self.required_bytes.is_some()
        }
        pub fn set_required_bytes(&mut self, v: impl pbrs::IntoProxied<ProtoBytes>) {
            self.cached_size.dirty();
            self.required_bytes = Some(Box::new(pbrs::rt::LazyBytes::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_required_bytes(&mut self) {
            self.cached_size.dirty();
            self.required_bytes = None;
        }
        pub fn has_required_nested_message(&self) -> bool {
            self.required_nested_message.is_some()
        }
        pub fn required_nested_message(&self) -> &NestedMessage {
            self.required_nested_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn required_nested_message_opt(&self) -> Option<&NestedMessage> {
            self.required_nested_message.as_deref()
        }
        pub fn required_nested_message_view(&self) -> NestedMessageView<'_> {
            NestedMessageView(self.required_nested_message())
        }
        pub fn set_required_nested_message(&mut self, v: NestedMessage) {
            self.cached_size.dirty();
            self.required_nested_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn required_nested_message_mut(&mut self) -> &mut NestedMessage {
            self.cached_size.dirty();
            self.required_nested_message.get_or_insert()
        }
        pub fn clear_required_nested_message(&mut self) {
            self.cached_size.dirty();
            self.required_nested_message.clear();
        }
        pub fn has_required_foreign_message(&self) -> bool {
            self.required_foreign_message.is_some()
        }
        pub fn required_foreign_message(&self) -> &ForeignMessageProto2 {
            self.required_foreign_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn required_foreign_message_opt(&self) -> Option<&ForeignMessageProto2> {
            self.required_foreign_message.as_deref()
        }
        pub fn required_foreign_message_view(&self) -> ForeignMessageProto2View<'_> {
            ForeignMessageProto2View(self.required_foreign_message())
        }
        pub fn set_required_foreign_message(&mut self, v: ForeignMessageProto2) {
            self.cached_size.dirty();
            self.required_foreign_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn required_foreign_message_mut(&mut self) -> &mut ForeignMessageProto2 {
            self.cached_size.dirty();
            self.required_foreign_message.get_or_insert()
        }
        pub fn clear_required_foreign_message(&mut self) {
            self.cached_size.dirty();
            self.required_foreign_message.clear();
        }
        pub fn has_required_nested_enum(&self) -> bool {
            self.required_nested_enum.is_some()
        }
        pub fn required_nested_enum(&self) -> NestedEnum {
            NestedEnum(self.required_nested_enum.unwrap_or(0))
        }
        pub fn required_nested_enum_opt(&self) -> Option<NestedEnum> {
            self.required_nested_enum.map(|v| NestedEnum(v))
        }
        pub fn set_required_nested_enum(&mut self, v: impl Into<i32>) {
            self.cached_size.dirty();
            self.required_nested_enum = Some(v.into());
        }
        pub fn clear_required_nested_enum(&mut self) {
            self.cached_size.dirty();
            self.required_nested_enum = None;
        }
        pub fn has_required_foreign_enum(&self) -> bool {
            self.required_foreign_enum.is_some()
        }
        pub fn required_foreign_enum(&self) -> ForeignEnumProto2 {
            ForeignEnumProto2(self.required_foreign_enum.unwrap_or(0))
        }
        pub fn required_foreign_enum_opt(&self) -> Option<ForeignEnumProto2> {
            self.required_foreign_enum.map(|v| ForeignEnumProto2(v))
        }
        pub fn set_required_foreign_enum(&mut self, v: impl Into<i32>) {
            self.cached_size.dirty();
            self.required_foreign_enum = Some(v.into());
        }
        pub fn clear_required_foreign_enum(&mut self) {
            self.cached_size.dirty();
            self.required_foreign_enum = None;
        }
        pub fn has_required_string_piece(&self) -> bool {
            self.required_string_piece.is_some()
        }
        pub fn required_string_piece(&self) -> &pbrs::ProtoStr {
            self.required_string_piece
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn required_string_piece_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.required_string_piece.as_ref().map(|s| s.as_view())
        }
        pub fn set_required_string_piece(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.required_string_piece = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_required_string_piece(&mut self) {
            self.cached_size.dirty();
            self.required_string_piece = None;
        }
        pub fn has_required_cord(&self) -> bool {
            self.required_cord.is_some()
        }
        pub fn required_cord(&self) -> &pbrs::ProtoStr {
            self.required_cord
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn required_cord_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.required_cord.as_ref().map(|s| s.as_view())
        }
        pub fn set_required_cord(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.required_cord = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_required_cord(&mut self) {
            self.cached_size.dirty();
            self.required_cord = None;
        }
        pub fn has_recursive_message(&self) -> bool {
            self.recursive_message.is_some()
        }
        pub fn recursive_message(&self) -> &TestAllRequiredTypesProto2 {
            self.recursive_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn recursive_message_opt(&self) -> Option<&TestAllRequiredTypesProto2> {
            self.recursive_message.as_deref()
        }
        pub fn recursive_message_view(&self) -> TestAllRequiredTypesProto2View<'_> {
            TestAllRequiredTypesProto2View(self.recursive_message())
        }
        pub fn set_recursive_message(&mut self, v: TestAllRequiredTypesProto2) {
            self.cached_size.dirty();
            self.recursive_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn recursive_message_mut(&mut self) -> &mut TestAllRequiredTypesProto2 {
            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 has_optional_recursive_message(&self) -> bool {
            self.optional_recursive_message.is_some()
        }
        pub fn optional_recursive_message(&self) -> &TestAllRequiredTypesProto2 {
            self.optional_recursive_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_recursive_message_opt(&self) -> Option<&TestAllRequiredTypesProto2> {
            self.optional_recursive_message.as_deref()
        }
        pub fn optional_recursive_message_view(&self) -> TestAllRequiredTypesProto2View<'_> {
            TestAllRequiredTypesProto2View(self.optional_recursive_message())
        }
        pub fn set_optional_recursive_message(&mut self, v: TestAllRequiredTypesProto2) {
            self.cached_size.dirty();
            self.optional_recursive_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_recursive_message_mut(&mut self) -> &mut TestAllRequiredTypesProto2 {
            self.cached_size.dirty();
            self.optional_recursive_message.get_or_insert()
        }
        pub fn clear_optional_recursive_message(&mut self) {
            self.cached_size.dirty();
            self.optional_recursive_message.clear();
        }
        pub fn has_data(&self) -> bool {
            self.data.is_some()
        }
        pub fn data(&self) -> &Data {
            self.data
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn data_opt(&self) -> Option<&Data> {
            self.data.as_deref()
        }
        pub fn data_view(&self) -> DataView<'_> {
            DataView(self.data())
        }
        pub fn set_data(&mut self, v: Data) {
            self.cached_size.dirty();
            self.data = Some(Box::new(v));
        }
        pub fn data_mut(&mut self) -> &mut Data {
            self.cached_size.dirty();
            self.data
                .get_or_insert_with(|| Box::new(Data::default()))
                .as_mut()
        }
        pub fn clear_data(&mut self) {
            self.cached_size.dirty();
            self.data = None;
        }
        pub fn has_default_int32(&self) -> bool {
            self.default_int32.is_some()
        }
        pub fn default_int32(&self) -> i32 {
            self.default_int32.unwrap_or(-123456789)
        }
        pub fn default_int32_opt(&self) -> Option<i32> {
            self.default_int32.map(|v| v)
        }
        pub fn set_default_int32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.default_int32 = Some(v);
        }
        pub fn clear_default_int32(&mut self) {
            self.cached_size.dirty();
            self.default_int32 = None;
        }
        pub fn has_default_int64(&self) -> bool {
            self.default_int64.is_some()
        }
        pub fn default_int64(&self) -> i64 {
            self.default_int64.unwrap_or(-9123456789123456789)
        }
        pub fn default_int64_opt(&self) -> Option<i64> {
            self.default_int64.map(|v| v)
        }
        pub fn set_default_int64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.default_int64 = Some(v);
        }
        pub fn clear_default_int64(&mut self) {
            self.cached_size.dirty();
            self.default_int64 = None;
        }
        pub fn has_default_uint32(&self) -> bool {
            self.default_uint32.is_some()
        }
        pub fn default_uint32(&self) -> u32 {
            self.default_uint32.unwrap_or(2123456789)
        }
        pub fn default_uint32_opt(&self) -> Option<u32> {
            self.default_uint32.map(|v| v)
        }
        pub fn set_default_uint32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.default_uint32 = Some(v);
        }
        pub fn clear_default_uint32(&mut self) {
            self.cached_size.dirty();
            self.default_uint32 = None;
        }
        pub fn has_default_uint64(&self) -> bool {
            self.default_uint64.is_some()
        }
        pub fn default_uint64(&self) -> u64 {
            self.default_uint64.unwrap_or(10123456789123456789)
        }
        pub fn default_uint64_opt(&self) -> Option<u64> {
            self.default_uint64.map(|v| v)
        }
        pub fn set_default_uint64(&mut self, v: u64) {
            self.cached_size.dirty();
            self.default_uint64 = Some(v);
        }
        pub fn clear_default_uint64(&mut self) {
            self.cached_size.dirty();
            self.default_uint64 = None;
        }
        pub fn has_default_sint32(&self) -> bool {
            self.default_sint32.is_some()
        }
        pub fn default_sint32(&self) -> i32 {
            self.default_sint32.unwrap_or(-123456789)
        }
        pub fn default_sint32_opt(&self) -> Option<i32> {
            self.default_sint32.map(|v| v)
        }
        pub fn set_default_sint32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.default_sint32 = Some(v);
        }
        pub fn clear_default_sint32(&mut self) {
            self.cached_size.dirty();
            self.default_sint32 = None;
        }
        pub fn has_default_sint64(&self) -> bool {
            self.default_sint64.is_some()
        }
        pub fn default_sint64(&self) -> i64 {
            self.default_sint64.unwrap_or(-9123456789123456789)
        }
        pub fn default_sint64_opt(&self) -> Option<i64> {
            self.default_sint64.map(|v| v)
        }
        pub fn set_default_sint64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.default_sint64 = Some(v);
        }
        pub fn clear_default_sint64(&mut self) {
            self.cached_size.dirty();
            self.default_sint64 = None;
        }
        pub fn has_default_fixed32(&self) -> bool {
            self.default_fixed32.is_some()
        }
        pub fn default_fixed32(&self) -> u32 {
            self.default_fixed32.unwrap_or(2123456789)
        }
        pub fn default_fixed32_opt(&self) -> Option<u32> {
            self.default_fixed32.map(|v| v)
        }
        pub fn set_default_fixed32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.default_fixed32 = Some(v);
        }
        pub fn clear_default_fixed32(&mut self) {
            self.cached_size.dirty();
            self.default_fixed32 = None;
        }
        pub fn has_default_fixed64(&self) -> bool {
            self.default_fixed64.is_some()
        }
        pub fn default_fixed64(&self) -> u64 {
            self.default_fixed64.unwrap_or(10123456789123456789)
        }
        pub fn default_fixed64_opt(&self) -> Option<u64> {
            self.default_fixed64.map(|v| v)
        }
        pub fn set_default_fixed64(&mut self, v: u64) {
            self.cached_size.dirty();
            self.default_fixed64 = Some(v);
        }
        pub fn clear_default_fixed64(&mut self) {
            self.cached_size.dirty();
            self.default_fixed64 = None;
        }
        pub fn has_default_sfixed32(&self) -> bool {
            self.default_sfixed32.is_some()
        }
        pub fn default_sfixed32(&self) -> i32 {
            self.default_sfixed32.unwrap_or(-123456789)
        }
        pub fn default_sfixed32_opt(&self) -> Option<i32> {
            self.default_sfixed32.map(|v| v)
        }
        pub fn set_default_sfixed32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.default_sfixed32 = Some(v);
        }
        pub fn clear_default_sfixed32(&mut self) {
            self.cached_size.dirty();
            self.default_sfixed32 = None;
        }
        pub fn has_default_sfixed64(&self) -> bool {
            self.default_sfixed64.is_some()
        }
        pub fn default_sfixed64(&self) -> i64 {
            self.default_sfixed64.unwrap_or(-9123456789123456789)
        }
        pub fn default_sfixed64_opt(&self) -> Option<i64> {
            self.default_sfixed64.map(|v| v)
        }
        pub fn set_default_sfixed64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.default_sfixed64 = Some(v);
        }
        pub fn clear_default_sfixed64(&mut self) {
            self.cached_size.dirty();
            self.default_sfixed64 = None;
        }
        pub fn has_default_float(&self) -> bool {
            self.default_float.is_some()
        }
        pub fn default_float(&self) -> f32 {
            self.default_float.unwrap_or(9e+09)
        }
        pub fn default_float_opt(&self) -> Option<f32> {
            self.default_float.map(|v| v)
        }
        pub fn set_default_float(&mut self, v: f32) {
            self.cached_size.dirty();
            self.default_float = Some(v);
        }
        pub fn clear_default_float(&mut self) {
            self.cached_size.dirty();
            self.default_float = None;
        }
        pub fn has_default_double(&self) -> bool {
            self.default_double.is_some()
        }
        pub fn default_double(&self) -> f64 {
            self.default_double.unwrap_or(7e+22)
        }
        pub fn default_double_opt(&self) -> Option<f64> {
            self.default_double.map(|v| v)
        }
        pub fn set_default_double(&mut self, v: f64) {
            self.cached_size.dirty();
            self.default_double = Some(v);
        }
        pub fn clear_default_double(&mut self) {
            self.cached_size.dirty();
            self.default_double = None;
        }
        pub fn has_default_bool(&self) -> bool {
            self.default_bool.is_some()
        }
        pub fn default_bool(&self) -> bool {
            self.default_bool.unwrap_or(true)
        }
        pub fn default_bool_opt(&self) -> Option<bool> {
            self.default_bool.get()
        }
        pub fn set_default_bool(&mut self, v: bool) {
            self.cached_size.dirty();
            self.default_bool = pbrs::rt::OptBool::some(v);
        }
        pub fn clear_default_bool(&mut self) {
            self.cached_size.dirty();
            self.default_bool = pbrs::rt::OptBool::NONE;
        }
        pub fn has_default_string(&self) -> bool {
            self.default_string.is_some()
        }
        pub fn default_string(&self) -> &pbrs::ProtoStr {
            self.default_string
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b"Rosebud"))
        }
        pub fn default_string_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.default_string.as_ref().map(|s| s.as_view())
        }
        pub fn set_default_string(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.default_string = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_default_string(&mut self) {
            self.cached_size.dirty();
            self.default_string = None;
        }
        pub fn default_bytes(&self) -> &[u8] {
            self.default_bytes
                .as_ref()
                .map(|b| b.as_bytes())
                .unwrap_or(b"joshua")
        }
        pub fn default_bytes_opt(&self) -> Option<&[u8]> {
            self.default_bytes.as_ref().map(|b| b.as_bytes())
        }
        pub fn has_default_bytes(&self) -> bool {
            self.default_bytes.is_some()
        }
        pub fn set_default_bytes(&mut self, v: impl pbrs::IntoProxied<ProtoBytes>) {
            self.cached_size.dirty();
            self.default_bytes = Some(Box::new(pbrs::rt::LazyBytes::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_default_bytes(&mut self) {
            self.cached_size.dirty();
            self.default_bytes = None;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            if self.required_int32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_int64.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_uint32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_uint64.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_sint32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_sint64.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_fixed32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_fixed64.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_sfixed32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_sfixed64.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_float.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_double.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_bool.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_string.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_bytes.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_nested_message.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_foreign_message.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_nested_enum.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_foreign_enum.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_string_piece.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.required_cord.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.recursive_message.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.data.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_int32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_int64.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_uint32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_uint64.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_sint32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_sint64.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_fixed32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_fixed64.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_sfixed32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_sfixed64.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_float.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_double.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_bool.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_string.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.default_bytes.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            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.required_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.required_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.required_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.required_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.required_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.required_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.required_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.required_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.required_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.required_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.required_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.required_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.required_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];
                            self.required_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.required_bytes = Some(Box::new(pbrs::rt::LazyBytes::from_wire(
                                pbrs::rt::Wire::ensure(wire, data).window(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.required_nested_message.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.required_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.required_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.required_foreign_message.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.required_foreign_message.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                ForeignMessageProto2::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.required_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.required_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.required_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];
                            self.required_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];
                            self.required_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;
                                TestAllRequiredTypesProto2::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)?),
                    },
                    28 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.optional_recursive_message.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.optional_recursive_message
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                TestAllRequiredTypesProto2::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.optional_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)?),
                    },
                    201 => match w {
                        pbrs::rt::WIRE_SGROUP => match &mut self.data {
                            Some(existing) => {
                                existing.merge_group(data, wire, pos, 201, depth + 1)?
                            }
                            None => {
                                let mut inner = Data::default();
                                inner.merge_group(data, wire, pos, 201, depth + 1)?;
                                self.data = Some(Box::new(inner));
                            }
                        },
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    241 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_int32 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    242 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_int64 = Some(pbrs::rt::decode_varint(data, pos)? as i64);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    243 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_uint32 = Some(pbrs::rt::decode_varint(data, pos)? as u32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    244 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_uint64 = Some(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    245 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_sint32 = Some(pbrs::rt::decode_zigzag32(
                                pbrs::rt::decode_varint(data, pos)?,
                            ));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    246 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_sint64 = Some(pbrs::rt::decode_zigzag64(
                                pbrs::rt::decode_varint(data, pos)?,
                            ));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    247 => match w {
                        pbrs::rt::WIRE_I32 => {
                            self.default_fixed32 = Some(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    248 => match w {
                        pbrs::rt::WIRE_I64 => {
                            self.default_fixed64 = Some(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    249 => match w {
                        pbrs::rt::WIRE_I32 => {
                            self.default_sfixed32 = Some(pbrs::rt::read_fixed32(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    250 => match w {
                        pbrs::rt::WIRE_I64 => {
                            self.default_sfixed64 = Some(pbrs::rt::read_fixed64(data, pos)? as i64);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    251 => match w {
                        pbrs::rt::WIRE_I32 => {
                            self.default_float =
                                Some(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    252 => match w {
                        pbrs::rt::WIRE_I64 => {
                            self.default_double =
                                Some(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    253 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_bool =
                                pbrs::rt::OptBool::some(pbrs::rt::decode_varint(data, pos)? != 0);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    254 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            self.default_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)?),
                    },
                    255 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.default_bytes = Some(Box::new(pbrs::rt::LazyBytes::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();
            let mut seen = 0u64;
            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;
                            seen |= 1 << 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    2 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i64;
                            seen |= 1 << 1;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    3 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                            seen |= 1 << 2;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    4 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                            seen |= 1 << 3;
                        }
                        _ => 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)?);
                            seen |= 1 << 4;
                        }
                        _ => 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)?);
                            seen |= 1 << 5;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    7 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)?;
                            seen |= 1 << 6;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    8 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)?;
                            seen |= 1 << 7;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    9 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
                            seen |= 1 << 8;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    10 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)? as i64;
                            seen |= 1 << 9;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    11 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                            seen |= 1 << 10;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    12 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                            seen |= 1 << 11;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    13 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                            seen |= 1 << 12;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    14 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            seen |= 1 << 13;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    15 => match w {
                        pbrs::rt::WIRE_LEN => {
                            pbrs::rt::read_len_span(data, pos)?;
                            seen |= 1 << 14;
                        }
                        _ => 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)?;
                            seen |= 1 << 15;
                        }
                        _ => 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;
                            ForeignMessageProto2::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                            seen |= 1 << 16;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    21 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                            seen |= 1 << 17;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    22 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                            seen |= 1 << 18;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    24 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            seen |= 1 << 19;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    25 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            seen |= 1 << 20;
                        }
                        _ => 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;
                            TestAllRequiredTypesProto2::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                            seen |= 1 << 21;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    28 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            TestAllRequiredTypesProto2::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    201 => match w {
                        pbrs::rt::WIRE_SGROUP => {
                            Data::validate_until(wire, pos, depth + 1, Some(201))?;
                            seen |= 1 << 22;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    241 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                            seen |= 1 << 23;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    242 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i64;
                            seen |= 1 << 24;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    243 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                            seen |= 1 << 25;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    244 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                            seen |= 1 << 26;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    245 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, pos)?);
                            seen |= 1 << 27;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    246 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, pos)?);
                            seen |= 1 << 28;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    247 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)?;
                            seen |= 1 << 29;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    248 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)?;
                            seen |= 1 << 30;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    249 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
                            seen |= 1 << 31;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    250 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)? as i64;
                            seen |= 1 << 32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    251 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                            seen |= 1 << 33;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    252 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                            seen |= 1 << 34;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    253 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                            seen |= 1 << 35;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    254 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            seen |= 1 << 36;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    255 => match w {
                        pbrs::rt::WIRE_LEN => {
                            pbrs::rt::read_len_span(data, pos)?;
                            seen |= 1 << 37;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    _ => pbrs::rt::skip_field(data, pos, w)?,
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            if seen != 274877906943 {
                return Err(ParseError::new("missing required field"));
            }
            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.required_int32 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.required_int64 {
                n += pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.required_uint32 {
                n += pbrs::rt::tag_len(3, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.required_uint64 {
                n += pbrs::rt::tag_len(4, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.required_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.required_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.required_fixed32 {
                n += pbrs::rt::tag_len(7, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.required_fixed64 {
                n += pbrs::rt::tag_len(8, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.required_sfixed32 {
                n += pbrs::rt::tag_len(9, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.required_sfixed64 {
                n += pbrs::rt::tag_len(10, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.required_float {
                n += pbrs::rt::tag_len(11, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.required_double {
                n += pbrs::rt::tag_len(12, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.required_bool.get() {
                n += pbrs::rt::tag_len(13, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(u64::from(v));
            }
            if let Some(s) = &self.required_string {
                n += pbrs::rt::key_len_value_len(14, s.as_bytes().len() as u64);
            }
            if let Some(s) = &self.required_bytes {
                n += pbrs::rt::key_len_value_len(15, s.as_bytes().len() as u64);
            }
            if let Some(p) = self.required_nested_message.wire_bytes() {
                n += pbrs::rt::key_len_value_len(18, p.len() as u64);
            } else if let Some(m) = self.required_nested_message.as_deref() {
                n += pbrs::rt::key_len_value_len(18, m.compute_size());
            }
            if let Some(p) = self.required_foreign_message.wire_bytes() {
                n += pbrs::rt::key_len_value_len(19, p.len() as u64);
            } else if let Some(m) = self.required_foreign_message.as_deref() {
                n += pbrs::rt::key_len_value_len(19, m.compute_size());
            }
            if let Some(v) = self.required_nested_enum {
                n +=
                    pbrs::rt::tag_len(21, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.required_foreign_enum {
                n +=
                    pbrs::rt::tag_len(22, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(s) = &self.required_string_piece {
                n += pbrs::rt::key_len_value_len(24, s.as_bytes().len() as u64);
            }
            if let Some(s) = &self.required_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());
            }
            if let Some(p) = self.optional_recursive_message.wire_bytes() {
                n += pbrs::rt::key_len_value_len(28, p.len() as u64);
            } else if let Some(m) = self.optional_recursive_message.as_deref() {
                n += pbrs::rt::key_len_value_len(28, m.compute_size());
            }
            if let Some(m) = &self.data {
                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(v) = self.default_int32 {
                n += pbrs::rt::tag_len(241, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.default_int64 {
                n += pbrs::rt::tag_len(242, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.default_uint32 {
                n += pbrs::rt::tag_len(243, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.default_uint64 {
                n += pbrs::rt::tag_len(244, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.default_sint32 {
                n += pbrs::rt::tag_len(245, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(v));
            }
            if let Some(v) = self.default_sint64 {
                n += pbrs::rt::tag_len(246, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(v));
            }
            if let Some(v) = self.default_fixed32 {
                n += pbrs::rt::tag_len(247, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.default_fixed64 {
                n += pbrs::rt::tag_len(248, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.default_sfixed32 {
                n += pbrs::rt::tag_len(249, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.default_sfixed64 {
                n += pbrs::rt::tag_len(250, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.default_float {
                n += pbrs::rt::tag_len(251, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.default_double {
                n += pbrs::rt::tag_len(252, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.default_bool.get() {
                n += pbrs::rt::tag_len(253, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(u64::from(v));
            }
            if let Some(s) = &self.default_string {
                n += pbrs::rt::key_len_value_len(254, s.as_bytes().len() as u64);
            }
            if let Some(s) = &self.default_bytes {
                n += pbrs::rt::key_len_value_len(255, s.as_bytes().len() as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(v) = self.required_int32 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.required_int64 {
                pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.required_uint32 {
                pbrs::rt::encode_tag(out, 3, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.required_uint64 {
                pbrs::rt::encode_tag(out, 4, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.required_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.required_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.required_fixed32 {
                pbrs::rt::encode_tag(out, 7, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(v).to_le_bytes());
            }
            if let Some(v) = self.required_fixed64 {
                pbrs::rt::encode_tag(out, 8, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(v).to_le_bytes());
            }
            if let Some(v) = self.required_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.required_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.required_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.required_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.required_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.required_string {
                pbrs::rt::encode_len_field(out, 14, s.as_bytes());
            }
            if let Some(s) = &self.required_bytes {
                pbrs::rt::encode_len_field(out, 15, s.as_bytes());
            }
            if let Some(p) = self.required_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.required_nested_message.as_deref() {
                pbrs::rt::encode_len_header(out, 18, m.compute_size());
                m.write_to(out);
            }
            if let Some(p) = self.required_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.required_foreign_message.as_deref() {
                pbrs::rt::encode_len_header(out, 19, m.compute_size());
                m.write_to(out);
            }
            if let Some(v) = self.required_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.required_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.required_string_piece {
                pbrs::rt::encode_len_field(out, 24, s.as_bytes());
            }
            if let Some(s) = &self.required_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);
            }
            if let Some(p) = self.optional_recursive_message.wire_bytes() {
                pbrs::rt::encode_len_header(out, 28, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.optional_recursive_message.as_deref() {
                pbrs::rt::encode_len_header(out, 28, m.compute_size());
                m.write_to(out);
            }
            if let Some(m) = &self.data {
                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(v) = self.default_int32 {
                pbrs::rt::encode_tag(out, 241, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.default_int64 {
                pbrs::rt::encode_tag(out, 242, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.default_uint32 {
                pbrs::rt::encode_tag(out, 243, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.default_uint64 {
                pbrs::rt::encode_tag(out, 244, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.default_sint32 {
                pbrs::rt::encode_tag(out, 245, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(v));
            }
            if let Some(v) = self.default_sint64 {
                pbrs::rt::encode_tag(out, 246, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(v));
            }
            if let Some(v) = self.default_fixed32 {
                pbrs::rt::encode_tag(out, 247, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(v).to_le_bytes());
            }
            if let Some(v) = self.default_fixed64 {
                pbrs::rt::encode_tag(out, 248, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(v).to_le_bytes());
            }
            if let Some(v) = self.default_sfixed32 {
                pbrs::rt::encode_tag(out, 249, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&((v) as u32).to_le_bytes());
            }
            if let Some(v) = self.default_sfixed64 {
                pbrs::rt::encode_tag(out, 250, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&((v) as u64).to_le_bytes());
            }
            if let Some(v) = self.default_float {
                pbrs::rt::encode_tag(out, 251, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(v).to_bits().to_le_bytes());
            }
            if let Some(v) = self.default_double {
                pbrs::rt::encode_tag(out, 252, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(v).to_bits().to_le_bytes());
            }
            if let Some(v) = self.default_bool.get() {
                pbrs::rt::encode_tag(out, 253, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, u64::from(v));
            }
            if let Some(s) = &self.default_string {
                pbrs::rt::encode_len_field(out, 254, s.as_bytes());
            }
            if let Some(s) = &self.default_bytes {
                pbrs::rt::encode_len_field(out, 255, s.as_bytes());
            }
            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.proto2.TestAllRequiredTypesProto2")
                .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.proto2.TestAllRequiredTypesProto2")
                .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.proto2.TestAllRequiredTypesProto2")
                .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.proto2.TestAllRequiredTypesProto2")
                .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.proto2.TestAllRequiredTypesProto2")
                .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!(
        TestAllRequiredTypesProto2,
        TestAllRequiredTypesProto2View,
        TestAllRequiredTypesProto2Mut
    );
    #[derive(Clone, Debug)]
    pub struct Data {
        group_int32: Option<i32>,
        group_uint32: Option<u32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for Data {
        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 Data {}
    impl Default for Data {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl Data {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = false;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data";
        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> {
            if self.group_int32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.group_uint32.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            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();
            let mut seen = 0u64;
            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;
                            seen |= 1 << 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    203 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                            seen |= 1 << 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"));
            }
            if seen != 3 {
                return Err(ParseError::new("missing required field"));
            }
            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.proto2.TestAllRequiredTypesProto2.Data")
                .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.proto2.TestAllRequiredTypesProto2.Data")
                .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.proto2.TestAllRequiredTypesProto2.Data")
                .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.proto2.TestAllRequiredTypesProto2.Data")
                .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.proto2.TestAllRequiredTypesProto2.Data")
                .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!(Data, DataView, DataMut);
    #[derive(Clone, Debug)]
    pub struct MessageSetCorrect {
        message_set_extension: pbrs::rt::LazyMsg<MessageSetCorrectExtension1>,
        message_set_extension_4135312: pbrs::rt::LazyMsg<MessageSetCorrectExtension2>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for MessageSetCorrect {
        fn eq(&self, other: &Self) -> bool {
            if self.message_set_extension != other.message_set_extension {
                return false;
            }
            if self.message_set_extension_4135312 != other.message_set_extension_4135312 {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for MessageSetCorrect {}
    impl Default for MessageSetCorrect {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl MessageSetCorrect {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.MessageSetCorrect";
        pub fn has_message_set_extension(&self) -> bool {
            self.message_set_extension.is_some()
        }
        pub fn message_set_extension(&self) -> &MessageSetCorrectExtension1 {
            self.message_set_extension
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn message_set_extension_opt(&self) -> Option<&MessageSetCorrectExtension1> {
            self.message_set_extension.as_deref()
        }
        pub fn message_set_extension_view(&self) -> MessageSetCorrectExtension1View<'_> {
            MessageSetCorrectExtension1View(self.message_set_extension())
        }
        pub fn set_message_set_extension(&mut self, v: MessageSetCorrectExtension1) {
            self.cached_size.dirty();
            self.message_set_extension = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn message_set_extension_mut(&mut self) -> &mut MessageSetCorrectExtension1 {
            self.cached_size.dirty();
            self.message_set_extension.get_or_insert()
        }
        pub fn clear_message_set_extension(&mut self) {
            self.cached_size.dirty();
            self.message_set_extension.clear();
        }
        pub fn has_message_set_extension_4135312(&self) -> bool {
            self.message_set_extension_4135312.is_some()
        }
        pub fn message_set_extension_4135312(&self) -> &MessageSetCorrectExtension2 {
            self.message_set_extension_4135312
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn message_set_extension_4135312_opt(&self) -> Option<&MessageSetCorrectExtension2> {
            self.message_set_extension_4135312.as_deref()
        }
        pub fn message_set_extension_4135312_view(&self) -> MessageSetCorrectExtension2View<'_> {
            MessageSetCorrectExtension2View(self.message_set_extension_4135312())
        }
        pub fn set_message_set_extension_4135312(&mut self, v: MessageSetCorrectExtension2) {
            self.cached_size.dirty();
            self.message_set_extension_4135312 = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn message_set_extension_4135312_mut(&mut self) -> &mut MessageSetCorrectExtension2 {
            self.cached_size.dirty();
            self.message_set_extension_4135312.get_or_insert()
        }
        pub fn clear_message_set_extension_4135312(&mut self) {
            self.cached_size.dirty();
            self.message_set_extension_4135312.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_SGROUP | pbrs::rt::WIRE_LEN => {
                            let mut type_id = 0u32;
                            let mut payload: Vec<u8> = Vec::new();
                            if w == pbrs::rt::WIRE_LEN {
                                let inner = pbrs::rt::read_len_bytes(data, pos)?;
                                let mut p = 0;
                                while p < inner.len() {
                                    let (n, ww) = pbrs::rt::decode_tag(inner, &mut p)?;
                                    match (n, ww) {
                                        (2, pbrs::rt::WIRE_VARINT) => {
                                            type_id = pbrs::rt::decode_varint(inner, &mut p)? as u32
                                        }
                                        (3, pbrs::rt::WIRE_LEN) => {
                                            payload =
                                                pbrs::rt::read_len_bytes(inner, &mut p)?.to_vec()
                                        }
                                        _ => pbrs::rt::skip_field(inner, &mut p, ww)?,
                                    }
                                }
                            } else {
                                loop {
                                    let (n, ww) = pbrs::rt::decode_tag(data, pos)?;
                                    if ww == pbrs::rt::WIRE_EGROUP && n == 1 {
                                        break;
                                    }
                                    match (n, ww) {
                                        (2, pbrs::rt::WIRE_VARINT) => {
                                            type_id = pbrs::rt::decode_varint(data, pos)? as u32
                                        }
                                        (3, pbrs::rt::WIRE_LEN) => {
                                            payload = pbrs::rt::read_len_bytes(data, pos)?.to_vec()
                                        }
                                        _ => pbrs::rt::skip_field(data, pos, ww)?,
                                    }
                                }
                            }
                            match type_id {
                                1547769 => {
                                    if self.message_set_extension.is_some() {
                                        self.message_set_extension
                                            .get_or_insert()
                                            .merge_bytes(&payload, depth + 1)?;
                                    } else {
                                        let mut inner = MessageSetCorrectExtension1::default();
                                        inner.merge_bytes(&payload, depth + 1)?;
                                        self.message_set_extension =
                                            pbrs::rt::LazyMsg::from_owned(inner);
                                    }
                                }
                                4135312 => {
                                    if self.message_set_extension_4135312.is_some() {
                                        self.message_set_extension_4135312
                                            .get_or_insert()
                                            .merge_bytes(&payload, depth + 1)?;
                                    } else {
                                        let mut inner = MessageSetCorrectExtension2::default();
                                        inner.merge_bytes(&payload, depth + 1)?;
                                        self.message_set_extension_4135312 =
                                            pbrs::rt::LazyMsg::from_owned(inner);
                                    }
                                }
                                _ => {
                                    let mut u = pbrs::UnknownFields::default();
                                    u.fields.push(pbrs::rt::UnknownField::Varint {
                                        number: 2,
                                        value: u64::from(type_id),
                                    });
                                    u.fields.push(pbrs::rt::UnknownField::LengthDelimited {
                                        number: 3,
                                        value: payload,
                                    });
                                    self.unknown.fields.push(pbrs::rt::UnknownField::Group {
                                        number: 1,
                                        fields: u,
                                    });
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    1547769 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.message_set_extension.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.message_set_extension.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                MessageSetCorrectExtension1::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.message_set_extension = 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)?),
                    },
                    4135312 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.message_set_extension_4135312.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.message_set_extension_4135312
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                MessageSetCorrectExtension2::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.message_set_extension_4135312 = 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 {
                    1547769 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            MessageSetCorrectExtension1::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    4135312 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            MessageSetCorrectExtension2::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(m) = self.message_set_extension.as_deref() {
                let inner = m.compute_size();
                let item = pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(1547769 as u64)
                    + pbrs::rt::key_len_value_len(3, inner);
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_SGROUP)
                    + item
                    + pbrs::rt::tag_len(1, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(m) = self.message_set_extension_4135312.as_deref() {
                let inner = m.compute_size();
                let item = pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(4135312 as u64)
                    + pbrs::rt::key_len_value_len(3, inner);
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_SGROUP)
                    + item
                    + pbrs::rt::tag_len(1, pbrs::rt::WIRE_EGROUP);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(m) = self.message_set_extension.as_deref() {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_SGROUP);
                pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, 1547769 as u64);
                pbrs::rt::encode_len_header(out, 3, m.compute_size());
                m.write_to(out);
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(m) = self.message_set_extension_4135312.as_deref() {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_SGROUP);
                pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, 4135312 as u64);
                pbrs::rt::encode_len_header(out, 3, m.compute_size());
                m.write_to(out);
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_EGROUP);
            }
            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.proto2.TestAllRequiredTypesProto2.MessageSetCorrect",
                )
                .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.proto2.TestAllRequiredTypesProto2.MessageSetCorrect",
                )
                .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.proto2.TestAllRequiredTypesProto2.MessageSetCorrect",
                )
                .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.proto2.TestAllRequiredTypesProto2.MessageSetCorrect",
                )
                .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.proto2.TestAllRequiredTypesProto2.MessageSetCorrect",
                )
                .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!(
        MessageSetCorrect,
        MessageSetCorrectView,
        MessageSetCorrectMut
    );
    #[derive(Clone, Debug)]
    pub struct MessageSetCorrectExtension1 {
        str: Option<Box<pbrs::rt::LazyStr>>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for MessageSetCorrectExtension1 {
        fn eq(&self, other: &Self) -> bool {
            if self.str != other.str {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for MessageSetCorrectExtension1 {}
    impl Default for MessageSetCorrectExtension1 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl MessageSetCorrectExtension1 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = false;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1";
        pub fn has_str(&self) -> bool {
            self.str.is_some()
        }
        pub fn str(&self) -> &pbrs::ProtoStr {
            self.str
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn str_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.str.as_ref().map(|s| s.as_view())
        }
        pub fn set_str(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.str = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_str(&mut self) {
            self.cached_size.dirty();
            self.str = None;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            if self.str.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            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 {
                    25 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            self.str = 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)?),
                    },
                    _ => 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();
            let mut seen = 0u64;
            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 {
                    25 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            seen |= 1 << 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    _ => pbrs::rt::skip_field(data, pos, w)?,
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            if seen != 1 {
                return Err(ParseError::new("missing required field"));
            }
            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(s) = &self.str {
                n += pbrs::rt::key_len_value_len(25, s.as_bytes().len() as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(s) = &self.str {
                pbrs::rt::encode_len_field(out, 25, s.as_bytes());
            }
            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.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1").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.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1").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.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1").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.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1").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.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1").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!(
        MessageSetCorrectExtension1,
        MessageSetCorrectExtension1View,
        MessageSetCorrectExtension1Mut
    );
    #[derive(Clone, Debug)]
    pub struct MessageSetCorrectExtension2 {
        i: Option<i32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for MessageSetCorrectExtension2 {
        fn eq(&self, other: &Self) -> bool {
            if self.i != other.i {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for MessageSetCorrectExtension2 {}
    impl Default for MessageSetCorrectExtension2 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl MessageSetCorrectExtension2 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = false;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2";
        pub fn has_i(&self) -> bool {
            self.i.is_some()
        }
        pub fn i(&self) -> i32 {
            self.i.unwrap_or(0)
        }
        pub fn i_opt(&self) -> Option<i32> {
            self.i.map(|v| v)
        }
        pub fn set_i(&mut self, v: i32) {
            self.cached_size.dirty();
            self.i = Some(v);
        }
        pub fn clear_i(&mut self) {
            self.cached_size.dirty();
            self.i = None;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            if self.i.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            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 {
                    9 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.i = 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();
            let mut seen = 0u64;
            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 {
                    9 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                            seen |= 1 << 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    _ => pbrs::rt::skip_field(data, pos, w)?,
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            if seen != 1 {
                return Err(ParseError::new("missing required field"));
            }
            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.i {
                n += pbrs::rt::tag_len(9, 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.i {
                pbrs::rt::encode_tag(out, 9, 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.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2").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.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2").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.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2").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.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2").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.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2").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!(
        MessageSetCorrectExtension2,
        MessageSetCorrectExtension2View,
        MessageSetCorrectExtension2Mut
    );
    #[derive(Clone, Debug)]
    pub struct NestedMessage {
        a: Option<i32>,
        corecursive: pbrs::rt::LazyMsg<TestAllRequiredTypesProto2>,
        optional_corecursive: pbrs::rt::LazyMsg<TestAllRequiredTypesProto2>,
        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;
            }
            if self.optional_corecursive != other.optional_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 = false;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.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) -> &TestAllRequiredTypesProto2 {
            self.corecursive
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn corecursive_opt(&self) -> Option<&TestAllRequiredTypesProto2> {
            self.corecursive.as_deref()
        }
        pub fn corecursive_view(&self) -> TestAllRequiredTypesProto2View<'_> {
            TestAllRequiredTypesProto2View(self.corecursive())
        }
        pub fn set_corecursive(&mut self, v: TestAllRequiredTypesProto2) {
            self.cached_size.dirty();
            self.corecursive = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn corecursive_mut(&mut self) -> &mut TestAllRequiredTypesProto2 {
            self.cached_size.dirty();
            self.corecursive.get_or_insert()
        }
        pub fn clear_corecursive(&mut self) {
            self.cached_size.dirty();
            self.corecursive.clear();
        }
        pub fn has_optional_corecursive(&self) -> bool {
            self.optional_corecursive.is_some()
        }
        pub fn optional_corecursive(&self) -> &TestAllRequiredTypesProto2 {
            self.optional_corecursive
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_corecursive_opt(&self) -> Option<&TestAllRequiredTypesProto2> {
            self.optional_corecursive.as_deref()
        }
        pub fn optional_corecursive_view(&self) -> TestAllRequiredTypesProto2View<'_> {
            TestAllRequiredTypesProto2View(self.optional_corecursive())
        }
        pub fn set_optional_corecursive(&mut self, v: TestAllRequiredTypesProto2) {
            self.cached_size.dirty();
            self.optional_corecursive = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_corecursive_mut(&mut self) -> &mut TestAllRequiredTypesProto2 {
            self.cached_size.dirty();
            self.optional_corecursive.get_or_insert()
        }
        pub fn clear_optional_corecursive(&mut self) {
            self.cached_size.dirty();
            self.optional_corecursive.clear();
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            if self.a.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            if self.corecursive.is_none() {
                return Err(ParseError::new("missing required field"));
            }
            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;
                                TestAllRequiredTypesProto2::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)?),
                    },
                    3 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.optional_corecursive.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.optional_corecursive.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                TestAllRequiredTypesProto2::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.optional_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();
            let mut seen = 0u64;
            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;
                            seen |= 1 << 0;
                        }
                        _ => 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;
                            TestAllRequiredTypesProto2::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                            seen |= 1 << 1;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    3 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            TestAllRequiredTypesProto2::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"));
            }
            if seen != 3 {
                return Err(ParseError::new("missing required field"));
            }
            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());
            }
            if let Some(p) = self.optional_corecursive.wire_bytes() {
                n += pbrs::rt::key_len_value_len(3, p.len() as u64);
            } else if let Some(m) = self.optional_corecursive.as_deref() {
                n += pbrs::rt::key_len_value_len(3, 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);
            }
            if let Some(p) = self.optional_corecursive.wire_bytes() {
                pbrs::rt::encode_len_header(out, 3, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.optional_corecursive.as_deref() {
                pbrs::rt::encode_len_header(out, 3, 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.proto2.TestAllRequiredTypesProto2.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.proto2.TestAllRequiredTypesProto2.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.proto2.TestAllRequiredTypesProto2.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.proto2.TestAllRequiredTypesProto2.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.proto2.TestAllRequiredTypesProto2.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);
    #[derive(Clone, Debug, PartialEq)]
    struct TestAllTypesProto2Cold {
        repeated_int32: Repeated<i32>,
        repeated_int64: Repeated<i64>,
        repeated_uint32: Repeated<u32>,
        repeated_uint64: Repeated<u64>,
        repeated_sint32: Repeated<i32>,
        repeated_sint64: Repeated<i64>,
        repeated_fixed32: Repeated<u32>,
        repeated_fixed64: Repeated<u64>,
        repeated_sfixed32: Repeated<i32>,
        repeated_sfixed64: Repeated<i64>,
        repeated_float: Repeated<f32>,
        repeated_double: Repeated<f64>,
        repeated_bool: Repeated<bool>,
        repeated_foreign_message: Repeated<ForeignMessageProto2>,
        repeated_nested_enum: Repeated<i32>,
        repeated_foreign_enum: Repeated<i32>,
        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 TestAllTypesProto2Cold {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TestAllTypesProto2 {
        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<TestAllTypesProto2NestedMessage>,
        optional_foreign_message: pbrs::rt::LazyMsg<ForeignMessageProto2>,
        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<TestAllTypesProto2>,
        repeated_string: Repeated<pbrs::rt::LazyStr>,
        repeated_bytes: Repeated<pbrs::rt::LazyBytes>,
        repeated_nested_message: Repeated<TestAllTypesProto2NestedMessage>,
        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, TestAllTypesProto2NestedMessage>,
        map_string_foreign_message: Map<pbrs::rt::LazyStr, ForeignMessageProto2>,
        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,
        map_int32_nested_message: Map<i32, TestAllTypesProto2NestedMessage>,
        map_int32_bool: Map<i32, bool>,
        oneof_uint32: Option<u32>,
        oneof_nested_message: pbrs::rt::LazyMsg<TestAllTypesProto2NestedMessage>,
        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>,
        groupfield: Option<Box<GroupField>>,
        extension_string: Option<Box<pbrs::rt::LazyStr>>,
        extension_bytes: Option<Box<pbrs::rt::LazyBytes>>,
        data: Option<Box<TestAllTypesProto2Data>>,
        multiwordgroupfield: Option<Box<MultiWordGroupField>>,
        default_int32: Option<i32>,
        default_int64: Option<i64>,
        default_uint32: Option<u32>,
        default_uint64: Option<u64>,
        default_sint32: Option<i32>,
        default_sint64: Option<i64>,
        default_fixed32: Option<u32>,
        default_fixed64: Option<u64>,
        default_sfixed32: Option<i32>,
        default_sfixed64: Option<i64>,
        default_float: Option<f32>,
        default_double: Option<f64>,
        default_bool: pbrs::rt::OptBool,
        default_string: Option<Box<pbrs::rt::LazyStr>>,
        default_bytes: Option<Box<pbrs::rt::LazyBytes>>,
        fieldname1: Option<i32>,
        field_name2: Option<i32>,
        _field_name3: Option<i32>,
        field__name4_: Option<i32>,
        field0name5: Option<i32>,
        field_0_name6: Option<i32>,
        fieldName7: Option<i32>,
        FieldName8: Option<i32>,
        field_Name9: Option<i32>,
        Field_Name10: Option<i32>,
        FIELD_NAME11: Option<i32>,
        FIELD_name12: Option<i32>,
        __field_name13: Option<i32>,
        __Field_name14: Option<i32>,
        field__name15: Option<i32>,
        field__Name16: Option<i32>,
        field_name17__: Option<i32>,
        Field_name18__: Option<i32>,
        message_set_correct: pbrs::rt::LazyMsg<TestAllTypesProto2MessageSetCorrect>,
        cold: Option<Box<TestAllTypesProto2Cold>>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for TestAllTypesProto2 {
        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.map_int32_nested_message != other.map_int32_nested_message {
                return false;
            }
            if self.map_int32_bool != other.map_int32_bool {
                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.groupfield != other.groupfield {
                return false;
            }
            if self.extension_string != other.extension_string {
                return false;
            }
            if self.extension_bytes != other.extension_bytes {
                return false;
            }
            if self.data != other.data {
                return false;
            }
            if self.multiwordgroupfield != other.multiwordgroupfield {
                return false;
            }
            if self.default_int32 != other.default_int32 {
                return false;
            }
            if self.default_int64 != other.default_int64 {
                return false;
            }
            if self.default_uint32 != other.default_uint32 {
                return false;
            }
            if self.default_uint64 != other.default_uint64 {
                return false;
            }
            if self.default_sint32 != other.default_sint32 {
                return false;
            }
            if self.default_sint64 != other.default_sint64 {
                return false;
            }
            if self.default_fixed32 != other.default_fixed32 {
                return false;
            }
            if self.default_fixed64 != other.default_fixed64 {
                return false;
            }
            if self.default_sfixed32 != other.default_sfixed32 {
                return false;
            }
            if self.default_sfixed64 != other.default_sfixed64 {
                return false;
            }
            if self.default_float != other.default_float {
                return false;
            }
            if self.default_double != other.default_double {
                return false;
            }
            if self.default_bool != other.default_bool {
                return false;
            }
            if self.default_string != other.default_string {
                return false;
            }
            if self.default_bytes != other.default_bytes {
                return false;
            }
            if self.fieldname1 != other.fieldname1 {
                return false;
            }
            if self.field_name2 != other.field_name2 {
                return false;
            }
            if self._field_name3 != other._field_name3 {
                return false;
            }
            if self.field__name4_ != other.field__name4_ {
                return false;
            }
            if self.field0name5 != other.field0name5 {
                return false;
            }
            if self.field_0_name6 != other.field_0_name6 {
                return false;
            }
            if self.fieldName7 != other.fieldName7 {
                return false;
            }
            if self.FieldName8 != other.FieldName8 {
                return false;
            }
            if self.field_Name9 != other.field_Name9 {
                return false;
            }
            if self.Field_Name10 != other.Field_Name10 {
                return false;
            }
            if self.FIELD_NAME11 != other.FIELD_NAME11 {
                return false;
            }
            if self.FIELD_name12 != other.FIELD_name12 {
                return false;
            }
            if self.__field_name13 != other.__field_name13 {
                return false;
            }
            if self.__Field_name14 != other.__Field_name14 {
                return false;
            }
            if self.field__name15 != other.field__name15 {
                return false;
            }
            if self.field__Name16 != other.field__Name16 {
                return false;
            }
            if self.field_name17__ != other.field_name17__ {
                return false;
            }
            if self.Field_name18__ != other.Field_name18__ {
                return false;
            }
            if self.message_set_correct != other.message_set_correct {
                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 != TestAllTypesProto2Cold::default() {
                        return false;
                    }
                }
                (Some(a), None) => {
                    if *a != TestAllTypesProto2Cold::default() {
                        return false;
                    }
                }
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for TestAllTypesProto2 {}
    impl Default for TestAllTypesProto2 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl TestAllTypesProto2 {
        pub fn new() -> Self {
            Self::default()
        }
        #[inline(always)]
        fn cold_mut(&mut self) -> &mut TestAllTypesProto2Cold {
            self.cold
                .get_or_insert_with(|| Box::new(TestAllTypesProto2Cold::default()))
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.TestAllTypesProto2";
        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) -> &TestAllTypesProto2NestedMessage {
            self.optional_nested_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_nested_message_opt(&self) -> Option<&TestAllTypesProto2NestedMessage> {
            self.optional_nested_message.as_deref()
        }
        pub fn optional_nested_message_view(&self) -> TestAllTypesProto2NestedMessageView<'_> {
            TestAllTypesProto2NestedMessageView(self.optional_nested_message())
        }
        pub fn set_optional_nested_message(&mut self, v: TestAllTypesProto2NestedMessage) {
            self.cached_size.dirty();
            self.optional_nested_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_nested_message_mut(&mut self) -> &mut TestAllTypesProto2NestedMessage {
            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) -> &ForeignMessageProto2 {
            self.optional_foreign_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_foreign_message_opt(&self) -> Option<&ForeignMessageProto2> {
            self.optional_foreign_message.as_deref()
        }
        pub fn optional_foreign_message_view(&self) -> ForeignMessageProto2View<'_> {
            ForeignMessageProto2View(self.optional_foreign_message())
        }
        pub fn set_optional_foreign_message(&mut self, v: ForeignMessageProto2) {
            self.cached_size.dirty();
            self.optional_foreign_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_foreign_message_mut(&mut self) -> &mut ForeignMessageProto2 {
            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) -> TestAllTypesProto2NestedEnum {
            TestAllTypesProto2NestedEnum(self.optional_nested_enum.unwrap_or(0))
        }
        pub fn optional_nested_enum_opt(&self) -> Option<TestAllTypesProto2NestedEnum> {
            self.optional_nested_enum
                .map(|v| TestAllTypesProto2NestedEnum(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) -> ForeignEnumProto2 {
            ForeignEnumProto2(self.optional_foreign_enum.unwrap_or(0))
        }
        pub fn optional_foreign_enum_opt(&self) -> Option<ForeignEnumProto2> {
            self.optional_foreign_enum.map(|v| ForeignEnumProto2(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) -> &TestAllTypesProto2 {
            self.recursive_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn recursive_message_opt(&self) -> Option<&TestAllTypesProto2> {
            self.recursive_message.as_deref()
        }
        pub fn recursive_message_view(&self) -> TestAllTypesProto2View<'_> {
            TestAllTypesProto2View(self.recursive_message())
        }
        pub fn set_recursive_message(&mut self, v: TestAllTypesProto2) {
            self.cached_size.dirty();
            self.recursive_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn recursive_message_mut(&mut self) -> &mut TestAllTypesProto2 {
            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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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<'_, TestAllTypesProto2NestedMessage> {
            self.repeated_nested_message.as_view()
        }
        pub fn repeated_nested_message_mut(
            &mut self,
        ) -> RepeatedMut<'_, TestAllTypesProto2NestedMessage> {
            self.cached_size.dirty();
            self.repeated_nested_message.as_mut()
        }
        pub fn set_repeated_nested_message(
            &mut self,
            v: impl IntoIterator<Item = TestAllTypesProto2NestedMessage>,
        ) {
            self.cached_size.dirty();
            self.repeated_nested_message = v.into_iter().collect();
        }
        pub fn repeated_foreign_message(&self) -> RepeatedView<'_, ForeignMessageProto2> {
            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<'_, ForeignMessageProto2> {
            self.cached_size.dirty();
            self.cold_mut().repeated_foreign_message.as_mut()
        }
        pub fn set_repeated_foreign_message(
            &mut self,
            v: impl IntoIterator<Item = ForeignMessageProto2>,
        ) {
            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 = 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 = 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, TestAllTypesProto2NestedMessage> {
            self.map_string_nested_message.as_view()
        }
        pub fn map_string_nested_message_mut(
            &mut self,
        ) -> MapMut<'_, pbrs::rt::LazyStr, TestAllTypesProto2NestedMessage> {
            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, TestAllTypesProto2NestedMessage>,
        ) {
            self.cached_size.dirty();
            self.map_string_nested_message = v;
        }
        pub fn map_string_foreign_message(
            &self,
        ) -> MapView<'_, pbrs::rt::LazyStr, ForeignMessageProto2> {
            self.map_string_foreign_message.as_view()
        }
        pub fn map_string_foreign_message_mut(
            &mut self,
        ) -> MapMut<'_, pbrs::rt::LazyStr, ForeignMessageProto2> {
            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, ForeignMessageProto2>,
        ) {
            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 map_int32_nested_message(
            &self,
        ) -> MapView<'_, i32, TestAllTypesProto2NestedMessage> {
            self.map_int32_nested_message.as_view()
        }
        pub fn map_int32_nested_message_mut(
            &mut self,
        ) -> MapMut<'_, i32, TestAllTypesProto2NestedMessage> {
            self.cached_size.dirty();
            self.map_int32_nested_message.as_mut()
        }
        pub fn set_map_int32_nested_message(
            &mut self,
            v: Map<i32, TestAllTypesProto2NestedMessage>,
        ) {
            self.cached_size.dirty();
            self.map_int32_nested_message = v;
        }
        pub fn map_int32_bool(&self) -> MapView<'_, i32, bool> {
            self.map_int32_bool.as_view()
        }
        pub fn map_int32_bool_mut(&mut self) -> MapMut<'_, i32, bool> {
            self.cached_size.dirty();
            self.map_int32_bool.as_mut()
        }
        pub fn set_map_int32_bool(&mut self, v: Map<i32, bool>) {
            self.cached_size.dirty();
            self.map_int32_bool = v;
        }
        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) -> &TestAllTypesProto2NestedMessage {
            self.oneof_nested_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn oneof_nested_message_opt(&self) -> Option<&TestAllTypesProto2NestedMessage> {
            self.oneof_nested_message.as_deref()
        }
        pub fn oneof_nested_message_view(&self) -> TestAllTypesProto2NestedMessageView<'_> {
            TestAllTypesProto2NestedMessageView(self.oneof_nested_message())
        }
        pub fn set_oneof_nested_message(&mut self, v: TestAllTypesProto2NestedMessage) {
            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 TestAllTypesProto2NestedMessage {
            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) -> TestAllTypesProto2NestedEnum {
            TestAllTypesProto2NestedEnum(self.oneof_enum.unwrap_or(0))
        }
        pub fn oneof_enum_opt(&self) -> Option<TestAllTypesProto2NestedEnum> {
            self.oneof_enum.map(|v| TestAllTypesProto2NestedEnum(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_groupfield(&self) -> bool {
            self.groupfield.is_some()
        }
        pub fn groupfield(&self) -> &GroupField {
            self.groupfield
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn groupfield_opt(&self) -> Option<&GroupField> {
            self.groupfield.as_deref()
        }
        pub fn groupfield_view(&self) -> GroupFieldView<'_> {
            GroupFieldView(self.groupfield())
        }
        pub fn set_groupfield(&mut self, v: GroupField) {
            self.cached_size.dirty();
            self.groupfield = Some(Box::new(v));
        }
        pub fn groupfield_mut(&mut self) -> &mut GroupField {
            self.cached_size.dirty();
            self.groupfield
                .get_or_insert_with(|| Box::new(GroupField::default()))
                .as_mut()
        }
        pub fn clear_groupfield(&mut self) {
            self.cached_size.dirty();
            self.groupfield = 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_data(&self) -> bool {
            self.data.is_some()
        }
        pub fn data(&self) -> &TestAllTypesProto2Data {
            self.data
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn data_opt(&self) -> Option<&TestAllTypesProto2Data> {
            self.data.as_deref()
        }
        pub fn data_view(&self) -> TestAllTypesProto2DataView<'_> {
            TestAllTypesProto2DataView(self.data())
        }
        pub fn set_data(&mut self, v: TestAllTypesProto2Data) {
            self.cached_size.dirty();
            self.data = Some(Box::new(v));
        }
        pub fn data_mut(&mut self) -> &mut TestAllTypesProto2Data {
            self.cached_size.dirty();
            self.data
                .get_or_insert_with(|| Box::new(TestAllTypesProto2Data::default()))
                .as_mut()
        }
        pub fn clear_data(&mut self) {
            self.cached_size.dirty();
            self.data = None;
        }
        pub fn has_multiwordgroupfield(&self) -> bool {
            self.multiwordgroupfield.is_some()
        }
        pub fn multiwordgroupfield(&self) -> &MultiWordGroupField {
            self.multiwordgroupfield
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn multiwordgroupfield_opt(&self) -> Option<&MultiWordGroupField> {
            self.multiwordgroupfield.as_deref()
        }
        pub fn multiwordgroupfield_view(&self) -> MultiWordGroupFieldView<'_> {
            MultiWordGroupFieldView(self.multiwordgroupfield())
        }
        pub fn set_multiwordgroupfield(&mut self, v: MultiWordGroupField) {
            self.cached_size.dirty();
            self.multiwordgroupfield = Some(Box::new(v));
        }
        pub fn multiwordgroupfield_mut(&mut self) -> &mut MultiWordGroupField {
            self.cached_size.dirty();
            self.multiwordgroupfield
                .get_or_insert_with(|| Box::new(MultiWordGroupField::default()))
                .as_mut()
        }
        pub fn clear_multiwordgroupfield(&mut self) {
            self.cached_size.dirty();
            self.multiwordgroupfield = None;
        }
        pub fn has_default_int32(&self) -> bool {
            self.default_int32.is_some()
        }
        pub fn default_int32(&self) -> i32 {
            self.default_int32.unwrap_or(-123456789)
        }
        pub fn default_int32_opt(&self) -> Option<i32> {
            self.default_int32.map(|v| v)
        }
        pub fn set_default_int32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.default_int32 = Some(v);
        }
        pub fn clear_default_int32(&mut self) {
            self.cached_size.dirty();
            self.default_int32 = None;
        }
        pub fn has_default_int64(&self) -> bool {
            self.default_int64.is_some()
        }
        pub fn default_int64(&self) -> i64 {
            self.default_int64.unwrap_or(-9123456789123456789)
        }
        pub fn default_int64_opt(&self) -> Option<i64> {
            self.default_int64.map(|v| v)
        }
        pub fn set_default_int64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.default_int64 = Some(v);
        }
        pub fn clear_default_int64(&mut self) {
            self.cached_size.dirty();
            self.default_int64 = None;
        }
        pub fn has_default_uint32(&self) -> bool {
            self.default_uint32.is_some()
        }
        pub fn default_uint32(&self) -> u32 {
            self.default_uint32.unwrap_or(2123456789)
        }
        pub fn default_uint32_opt(&self) -> Option<u32> {
            self.default_uint32.map(|v| v)
        }
        pub fn set_default_uint32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.default_uint32 = Some(v);
        }
        pub fn clear_default_uint32(&mut self) {
            self.cached_size.dirty();
            self.default_uint32 = None;
        }
        pub fn has_default_uint64(&self) -> bool {
            self.default_uint64.is_some()
        }
        pub fn default_uint64(&self) -> u64 {
            self.default_uint64.unwrap_or(10123456789123456789)
        }
        pub fn default_uint64_opt(&self) -> Option<u64> {
            self.default_uint64.map(|v| v)
        }
        pub fn set_default_uint64(&mut self, v: u64) {
            self.cached_size.dirty();
            self.default_uint64 = Some(v);
        }
        pub fn clear_default_uint64(&mut self) {
            self.cached_size.dirty();
            self.default_uint64 = None;
        }
        pub fn has_default_sint32(&self) -> bool {
            self.default_sint32.is_some()
        }
        pub fn default_sint32(&self) -> i32 {
            self.default_sint32.unwrap_or(-123456789)
        }
        pub fn default_sint32_opt(&self) -> Option<i32> {
            self.default_sint32.map(|v| v)
        }
        pub fn set_default_sint32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.default_sint32 = Some(v);
        }
        pub fn clear_default_sint32(&mut self) {
            self.cached_size.dirty();
            self.default_sint32 = None;
        }
        pub fn has_default_sint64(&self) -> bool {
            self.default_sint64.is_some()
        }
        pub fn default_sint64(&self) -> i64 {
            self.default_sint64.unwrap_or(-9123456789123456789)
        }
        pub fn default_sint64_opt(&self) -> Option<i64> {
            self.default_sint64.map(|v| v)
        }
        pub fn set_default_sint64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.default_sint64 = Some(v);
        }
        pub fn clear_default_sint64(&mut self) {
            self.cached_size.dirty();
            self.default_sint64 = None;
        }
        pub fn has_default_fixed32(&self) -> bool {
            self.default_fixed32.is_some()
        }
        pub fn default_fixed32(&self) -> u32 {
            self.default_fixed32.unwrap_or(2123456789)
        }
        pub fn default_fixed32_opt(&self) -> Option<u32> {
            self.default_fixed32.map(|v| v)
        }
        pub fn set_default_fixed32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.default_fixed32 = Some(v);
        }
        pub fn clear_default_fixed32(&mut self) {
            self.cached_size.dirty();
            self.default_fixed32 = None;
        }
        pub fn has_default_fixed64(&self) -> bool {
            self.default_fixed64.is_some()
        }
        pub fn default_fixed64(&self) -> u64 {
            self.default_fixed64.unwrap_or(10123456789123456789)
        }
        pub fn default_fixed64_opt(&self) -> Option<u64> {
            self.default_fixed64.map(|v| v)
        }
        pub fn set_default_fixed64(&mut self, v: u64) {
            self.cached_size.dirty();
            self.default_fixed64 = Some(v);
        }
        pub fn clear_default_fixed64(&mut self) {
            self.cached_size.dirty();
            self.default_fixed64 = None;
        }
        pub fn has_default_sfixed32(&self) -> bool {
            self.default_sfixed32.is_some()
        }
        pub fn default_sfixed32(&self) -> i32 {
            self.default_sfixed32.unwrap_or(-123456789)
        }
        pub fn default_sfixed32_opt(&self) -> Option<i32> {
            self.default_sfixed32.map(|v| v)
        }
        pub fn set_default_sfixed32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.default_sfixed32 = Some(v);
        }
        pub fn clear_default_sfixed32(&mut self) {
            self.cached_size.dirty();
            self.default_sfixed32 = None;
        }
        pub fn has_default_sfixed64(&self) -> bool {
            self.default_sfixed64.is_some()
        }
        pub fn default_sfixed64(&self) -> i64 {
            self.default_sfixed64.unwrap_or(-9123456789123456789)
        }
        pub fn default_sfixed64_opt(&self) -> Option<i64> {
            self.default_sfixed64.map(|v| v)
        }
        pub fn set_default_sfixed64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.default_sfixed64 = Some(v);
        }
        pub fn clear_default_sfixed64(&mut self) {
            self.cached_size.dirty();
            self.default_sfixed64 = None;
        }
        pub fn has_default_float(&self) -> bool {
            self.default_float.is_some()
        }
        pub fn default_float(&self) -> f32 {
            self.default_float.unwrap_or(9e+09)
        }
        pub fn default_float_opt(&self) -> Option<f32> {
            self.default_float.map(|v| v)
        }
        pub fn set_default_float(&mut self, v: f32) {
            self.cached_size.dirty();
            self.default_float = Some(v);
        }
        pub fn clear_default_float(&mut self) {
            self.cached_size.dirty();
            self.default_float = None;
        }
        pub fn has_default_double(&self) -> bool {
            self.default_double.is_some()
        }
        pub fn default_double(&self) -> f64 {
            self.default_double.unwrap_or(7e+22)
        }
        pub fn default_double_opt(&self) -> Option<f64> {
            self.default_double.map(|v| v)
        }
        pub fn set_default_double(&mut self, v: f64) {
            self.cached_size.dirty();
            self.default_double = Some(v);
        }
        pub fn clear_default_double(&mut self) {
            self.cached_size.dirty();
            self.default_double = None;
        }
        pub fn has_default_bool(&self) -> bool {
            self.default_bool.is_some()
        }
        pub fn default_bool(&self) -> bool {
            self.default_bool.unwrap_or(true)
        }
        pub fn default_bool_opt(&self) -> Option<bool> {
            self.default_bool.get()
        }
        pub fn set_default_bool(&mut self, v: bool) {
            self.cached_size.dirty();
            self.default_bool = pbrs::rt::OptBool::some(v);
        }
        pub fn clear_default_bool(&mut self) {
            self.cached_size.dirty();
            self.default_bool = pbrs::rt::OptBool::NONE;
        }
        pub fn has_default_string(&self) -> bool {
            self.default_string.is_some()
        }
        pub fn default_string(&self) -> &pbrs::ProtoStr {
            self.default_string
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b"Rosebud"))
        }
        pub fn default_string_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.default_string.as_ref().map(|s| s.as_view())
        }
        pub fn set_default_string(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.default_string = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_default_string(&mut self) {
            self.cached_size.dirty();
            self.default_string = None;
        }
        pub fn default_bytes(&self) -> &[u8] {
            self.default_bytes
                .as_ref()
                .map(|b| b.as_bytes())
                .unwrap_or(b"joshua")
        }
        pub fn default_bytes_opt(&self) -> Option<&[u8]> {
            self.default_bytes.as_ref().map(|b| b.as_bytes())
        }
        pub fn has_default_bytes(&self) -> bool {
            self.default_bytes.is_some()
        }
        pub fn set_default_bytes(&mut self, v: impl pbrs::IntoProxied<ProtoBytes>) {
            self.cached_size.dirty();
            self.default_bytes = Some(Box::new(pbrs::rt::LazyBytes::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_default_bytes(&mut self) {
            self.cached_size.dirty();
            self.default_bytes = None;
        }
        pub fn has_fieldname1(&self) -> bool {
            self.fieldname1.is_some()
        }
        pub fn fieldname1(&self) -> i32 {
            self.fieldname1.unwrap_or(0)
        }
        pub fn fieldname1_opt(&self) -> Option<i32> {
            self.fieldname1.map(|v| v)
        }
        pub fn set_fieldname1(&mut self, v: i32) {
            self.cached_size.dirty();
            self.fieldname1 = Some(v);
        }
        pub fn clear_fieldname1(&mut self) {
            self.cached_size.dirty();
            self.fieldname1 = None;
        }
        pub fn has_field_name2(&self) -> bool {
            self.field_name2.is_some()
        }
        pub fn field_name2(&self) -> i32 {
            self.field_name2.unwrap_or(0)
        }
        pub fn field_name2_opt(&self) -> Option<i32> {
            self.field_name2.map(|v| v)
        }
        pub fn set_field_name2(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field_name2 = Some(v);
        }
        pub fn clear_field_name2(&mut self) {
            self.cached_size.dirty();
            self.field_name2 = None;
        }
        pub fn has__field_name3(&self) -> bool {
            self._field_name3.is_some()
        }
        pub fn _field_name3(&self) -> i32 {
            self._field_name3.unwrap_or(0)
        }
        pub fn _field_name3_opt(&self) -> Option<i32> {
            self._field_name3.map(|v| v)
        }
        pub fn set__field_name3(&mut self, v: i32) {
            self.cached_size.dirty();
            self._field_name3 = Some(v);
        }
        pub fn clear__field_name3(&mut self) {
            self.cached_size.dirty();
            self._field_name3 = None;
        }
        pub fn has_field__name4_(&self) -> bool {
            self.field__name4_.is_some()
        }
        pub fn field__name4_(&self) -> i32 {
            self.field__name4_.unwrap_or(0)
        }
        pub fn field__name4__opt(&self) -> Option<i32> {
            self.field__name4_.map(|v| v)
        }
        pub fn set_field__name4_(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field__name4_ = Some(v);
        }
        pub fn clear_field__name4_(&mut self) {
            self.cached_size.dirty();
            self.field__name4_ = None;
        }
        pub fn has_field0name5(&self) -> bool {
            self.field0name5.is_some()
        }
        pub fn field0name5(&self) -> i32 {
            self.field0name5.unwrap_or(0)
        }
        pub fn field0name5_opt(&self) -> Option<i32> {
            self.field0name5.map(|v| v)
        }
        pub fn set_field0name5(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field0name5 = Some(v);
        }
        pub fn clear_field0name5(&mut self) {
            self.cached_size.dirty();
            self.field0name5 = None;
        }
        pub fn has_field_0_name6(&self) -> bool {
            self.field_0_name6.is_some()
        }
        pub fn field_0_name6(&self) -> i32 {
            self.field_0_name6.unwrap_or(0)
        }
        pub fn field_0_name6_opt(&self) -> Option<i32> {
            self.field_0_name6.map(|v| v)
        }
        pub fn set_field_0_name6(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field_0_name6 = Some(v);
        }
        pub fn clear_field_0_name6(&mut self) {
            self.cached_size.dirty();
            self.field_0_name6 = None;
        }
        pub fn has_fieldName7(&self) -> bool {
            self.fieldName7.is_some()
        }
        pub fn fieldName7(&self) -> i32 {
            self.fieldName7.unwrap_or(0)
        }
        pub fn fieldName7_opt(&self) -> Option<i32> {
            self.fieldName7.map(|v| v)
        }
        pub fn set_fieldName7(&mut self, v: i32) {
            self.cached_size.dirty();
            self.fieldName7 = Some(v);
        }
        pub fn clear_fieldName7(&mut self) {
            self.cached_size.dirty();
            self.fieldName7 = None;
        }
        pub fn has_FieldName8(&self) -> bool {
            self.FieldName8.is_some()
        }
        pub fn FieldName8(&self) -> i32 {
            self.FieldName8.unwrap_or(0)
        }
        pub fn FieldName8_opt(&self) -> Option<i32> {
            self.FieldName8.map(|v| v)
        }
        pub fn set_FieldName8(&mut self, v: i32) {
            self.cached_size.dirty();
            self.FieldName8 = Some(v);
        }
        pub fn clear_FieldName8(&mut self) {
            self.cached_size.dirty();
            self.FieldName8 = None;
        }
        pub fn has_field_Name9(&self) -> bool {
            self.field_Name9.is_some()
        }
        pub fn field_Name9(&self) -> i32 {
            self.field_Name9.unwrap_or(0)
        }
        pub fn field_Name9_opt(&self) -> Option<i32> {
            self.field_Name9.map(|v| v)
        }
        pub fn set_field_Name9(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field_Name9 = Some(v);
        }
        pub fn clear_field_Name9(&mut self) {
            self.cached_size.dirty();
            self.field_Name9 = None;
        }
        pub fn has_Field_Name10(&self) -> bool {
            self.Field_Name10.is_some()
        }
        pub fn Field_Name10(&self) -> i32 {
            self.Field_Name10.unwrap_or(0)
        }
        pub fn Field_Name10_opt(&self) -> Option<i32> {
            self.Field_Name10.map(|v| v)
        }
        pub fn set_Field_Name10(&mut self, v: i32) {
            self.cached_size.dirty();
            self.Field_Name10 = Some(v);
        }
        pub fn clear_Field_Name10(&mut self) {
            self.cached_size.dirty();
            self.Field_Name10 = None;
        }
        pub fn has_FIELD_NAME11(&self) -> bool {
            self.FIELD_NAME11.is_some()
        }
        pub fn FIELD_NAME11(&self) -> i32 {
            self.FIELD_NAME11.unwrap_or(0)
        }
        pub fn FIELD_NAME11_opt(&self) -> Option<i32> {
            self.FIELD_NAME11.map(|v| v)
        }
        pub fn set_FIELD_NAME11(&mut self, v: i32) {
            self.cached_size.dirty();
            self.FIELD_NAME11 = Some(v);
        }
        pub fn clear_FIELD_NAME11(&mut self) {
            self.cached_size.dirty();
            self.FIELD_NAME11 = None;
        }
        pub fn has_FIELD_name12(&self) -> bool {
            self.FIELD_name12.is_some()
        }
        pub fn FIELD_name12(&self) -> i32 {
            self.FIELD_name12.unwrap_or(0)
        }
        pub fn FIELD_name12_opt(&self) -> Option<i32> {
            self.FIELD_name12.map(|v| v)
        }
        pub fn set_FIELD_name12(&mut self, v: i32) {
            self.cached_size.dirty();
            self.FIELD_name12 = Some(v);
        }
        pub fn clear_FIELD_name12(&mut self) {
            self.cached_size.dirty();
            self.FIELD_name12 = None;
        }
        pub fn has___field_name13(&self) -> bool {
            self.__field_name13.is_some()
        }
        pub fn __field_name13(&self) -> i32 {
            self.__field_name13.unwrap_or(0)
        }
        pub fn __field_name13_opt(&self) -> Option<i32> {
            self.__field_name13.map(|v| v)
        }
        pub fn set___field_name13(&mut self, v: i32) {
            self.cached_size.dirty();
            self.__field_name13 = Some(v);
        }
        pub fn clear___field_name13(&mut self) {
            self.cached_size.dirty();
            self.__field_name13 = None;
        }
        pub fn has___Field_name14(&self) -> bool {
            self.__Field_name14.is_some()
        }
        pub fn __Field_name14(&self) -> i32 {
            self.__Field_name14.unwrap_or(0)
        }
        pub fn __Field_name14_opt(&self) -> Option<i32> {
            self.__Field_name14.map(|v| v)
        }
        pub fn set___Field_name14(&mut self, v: i32) {
            self.cached_size.dirty();
            self.__Field_name14 = Some(v);
        }
        pub fn clear___Field_name14(&mut self) {
            self.cached_size.dirty();
            self.__Field_name14 = None;
        }
        pub fn has_field__name15(&self) -> bool {
            self.field__name15.is_some()
        }
        pub fn field__name15(&self) -> i32 {
            self.field__name15.unwrap_or(0)
        }
        pub fn field__name15_opt(&self) -> Option<i32> {
            self.field__name15.map(|v| v)
        }
        pub fn set_field__name15(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field__name15 = Some(v);
        }
        pub fn clear_field__name15(&mut self) {
            self.cached_size.dirty();
            self.field__name15 = None;
        }
        pub fn has_field__Name16(&self) -> bool {
            self.field__Name16.is_some()
        }
        pub fn field__Name16(&self) -> i32 {
            self.field__Name16.unwrap_or(0)
        }
        pub fn field__Name16_opt(&self) -> Option<i32> {
            self.field__Name16.map(|v| v)
        }
        pub fn set_field__Name16(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field__Name16 = Some(v);
        }
        pub fn clear_field__Name16(&mut self) {
            self.cached_size.dirty();
            self.field__Name16 = None;
        }
        pub fn has_field_name17__(&self) -> bool {
            self.field_name17__.is_some()
        }
        pub fn field_name17__(&self) -> i32 {
            self.field_name17__.unwrap_or(0)
        }
        pub fn field_name17___opt(&self) -> Option<i32> {
            self.field_name17__.map(|v| v)
        }
        pub fn set_field_name17__(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field_name17__ = Some(v);
        }
        pub fn clear_field_name17__(&mut self) {
            self.cached_size.dirty();
            self.field_name17__ = None;
        }
        pub fn has_Field_name18__(&self) -> bool {
            self.Field_name18__.is_some()
        }
        pub fn Field_name18__(&self) -> i32 {
            self.Field_name18__.unwrap_or(0)
        }
        pub fn Field_name18___opt(&self) -> Option<i32> {
            self.Field_name18__.map(|v| v)
        }
        pub fn set_Field_name18__(&mut self, v: i32) {
            self.cached_size.dirty();
            self.Field_name18__ = Some(v);
        }
        pub fn clear_Field_name18__(&mut self) {
            self.cached_size.dirty();
            self.Field_name18__ = None;
        }
        pub fn has_message_set_correct(&self) -> bool {
            self.message_set_correct.is_some()
        }
        pub fn message_set_correct(&self) -> &TestAllTypesProto2MessageSetCorrect {
            self.message_set_correct
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn message_set_correct_opt(&self) -> Option<&TestAllTypesProto2MessageSetCorrect> {
            self.message_set_correct.as_deref()
        }
        pub fn message_set_correct_view(&self) -> TestAllTypesProto2MessageSetCorrectView<'_> {
            TestAllTypesProto2MessageSetCorrectView(self.message_set_correct())
        }
        pub fn set_message_set_correct(&mut self, v: TestAllTypesProto2MessageSetCorrect) {
            self.cached_size.dirty();
            self.message_set_correct = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn message_set_correct_mut(&mut self) -> &mut TestAllTypesProto2MessageSetCorrect {
            self.cached_size.dirty();
            self.message_set_correct.get_or_insert()
        }
        pub fn clear_message_set_correct(&mut self) {
            self.cached_size.dirty();
            self.message_set_correct.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.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];
                            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_wire(
                                pbrs::rt::Wire::ensure(wire, data).window(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;
                                TestAllTypesProto2NestedMessage::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;
                                ForeignMessageProto2::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];
                            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];
                            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;
                                TestAllTypesProto2::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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_int32
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as i32);
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_int64
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as i64);
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_uint32
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as u32);
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_uint64
                                    .push(pbrs::rt::decode_varint(p, &mut i)?);
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_sint32
                                    .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                        p, &mut i,
                                    )?));
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_sint64
                                    .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                        p, &mut i,
                                    )?));
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_fixed32
                                    .push(pbrs::rt::read_fixed32(p, &mut i)?);
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_fixed64
                                    .push(pbrs::rt::read_fixed64(p, &mut i)?);
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_sfixed32
                                    .push(pbrs::rt::read_fixed32(p, &mut i)? as i32);
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_sfixed64
                                    .push(pbrs::rt::read_fixed64(p, &mut i)? as i64);
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_float
                                    .push(f32::from_bits(pbrs::rt::read_fixed32(p, &mut i)?));
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_double
                                    .push(f64::from_bits(pbrs::rt::read_fixed64(p, &mut i)?));
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_bool
                                    .push(pbrs::rt::decode_varint(p, &mut i)? != 0);
                            }
                        }
                        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];
                            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_wire(
                                pbrs::rt::Wire::ensure(wire, data).window(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 = TestAllTypesProto2NestedMessage::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 = TestAllTypesProto2NestedMessage::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 = ForeignMessageProto2::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 = ForeignMessageProto2::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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_nested_enum
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as i32);
                            }
                        }
                        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 p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .repeated_foreign_enum
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as i32);
                            }
                        }
                        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];
                            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];
                            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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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)?),
                    },
                    103 => {
                        match w {
                            pbrs::rt::WIRE_LEN => {
                                let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                let (kk, vv) = decode_map_entry_TestAllTypesProto2_map_int32_nested_message_103(&pbrs::rt::Wire::ensure(wire, data).window(s, e), depth + 1)?;
                                self.map_int32_nested_message.push_entry(kk, vv);
                            }
                            _ => self
                                .unknown
                                .fields
                                .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                        }
                    }
                    104 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) = decode_map_entry_TestAllTypesProto2_map_int32_bool_104(
                                &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                depth + 1,
                            )?;
                            self.map_int32_bool.push_entry(kk, vv);
                        }
                        _ => 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;
                                TestAllTypesProto2NestedMessage::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];
                            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_wire(
                                pbrs::rt::Wire::ensure(wire, data).window(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.groupfield {
                            Some(existing) => {
                                existing.merge_group(data, wire, pos, 121, depth + 1)?
                            }
                            None => {
                                let mut inner = GroupField::default();
                                inner.merge_group(data, wire, pos, 121, depth + 1)?;
                                self.groupfield = 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];
                            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_wire(
                                pbrs::rt::Wire::ensure(wire, data).window(s, e),
                            )));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    201 => match w {
                        pbrs::rt::WIRE_SGROUP => match &mut self.data {
                            Some(existing) => {
                                existing.merge_group(data, wire, pos, 201, depth + 1)?
                            }
                            None => {
                                let mut inner = TestAllTypesProto2Data::default();
                                inner.merge_group(data, wire, pos, 201, depth + 1)?;
                                self.data = Some(Box::new(inner));
                            }
                        },
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    204 => match w {
                        pbrs::rt::WIRE_SGROUP => match &mut self.multiwordgroupfield {
                            Some(existing) => {
                                existing.merge_group(data, wire, pos, 204, depth + 1)?
                            }
                            None => {
                                let mut inner = MultiWordGroupField::default();
                                inner.merge_group(data, wire, pos, 204, depth + 1)?;
                                self.multiwordgroupfield = Some(Box::new(inner));
                            }
                        },
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    241 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_int32 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    242 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_int64 = Some(pbrs::rt::decode_varint(data, pos)? as i64);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    243 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_uint32 = Some(pbrs::rt::decode_varint(data, pos)? as u32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    244 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_uint64 = Some(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    245 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_sint32 = Some(pbrs::rt::decode_zigzag32(
                                pbrs::rt::decode_varint(data, pos)?,
                            ));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    246 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_sint64 = Some(pbrs::rt::decode_zigzag64(
                                pbrs::rt::decode_varint(data, pos)?,
                            ));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    247 => match w {
                        pbrs::rt::WIRE_I32 => {
                            self.default_fixed32 = Some(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    248 => match w {
                        pbrs::rt::WIRE_I64 => {
                            self.default_fixed64 = Some(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    249 => match w {
                        pbrs::rt::WIRE_I32 => {
                            self.default_sfixed32 = Some(pbrs::rt::read_fixed32(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    250 => match w {
                        pbrs::rt::WIRE_I64 => {
                            self.default_sfixed64 = Some(pbrs::rt::read_fixed64(data, pos)? as i64);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    251 => match w {
                        pbrs::rt::WIRE_I32 => {
                            self.default_float =
                                Some(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    252 => match w {
                        pbrs::rt::WIRE_I64 => {
                            self.default_double =
                                Some(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    253 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.default_bool =
                                pbrs::rt::OptBool::some(pbrs::rt::decode_varint(data, pos)? != 0);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    254 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            self.default_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)?),
                    },
                    255 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.default_bytes = Some(Box::new(pbrs::rt::LazyBytes::from_wire(
                                pbrs::rt::Wire::ensure(wire, data).window(s, e),
                            )));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    401 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.fieldname1 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    402 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.field_name2 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    403 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self._field_name3 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    404 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.field__name4_ = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    405 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.field0name5 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    406 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.field_0_name6 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    407 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.fieldName7 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    408 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.FieldName8 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    409 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.field_Name9 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    410 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.Field_Name10 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    411 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.FIELD_NAME11 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    412 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.FIELD_name12 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    413 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.__field_name13 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    414 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.__Field_name14 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    415 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.field__name15 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    416 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.field__Name16 = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    417 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.field_name17__ = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    418 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.Field_name18__ = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    500 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.message_set_correct.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.message_set_correct.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                TestAllTypesProto2MessageSetCorrect::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.message_set_correct = 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_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)?;
                        }
                        _ => 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;
                            TestAllTypesProto2NestedMessage::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;
                            ForeignMessageProto2::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)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    25 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => 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;
                            TestAllTypesProto2::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)?;
                        }
                        _ => 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;
                            TestAllTypesProto2NestedMessage::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;
                            ForeignMessageProto2::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)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    55 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => 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)?,
                    },
                    103 => 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)?,
                    },
                    104 => 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)?,
                    },
                    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;
                            TestAllTypesProto2NestedMessage::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)?;
                        }
                        _ => 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 => {
                            GroupField::validate_until(wire, pos, depth + 1, Some(121))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    133 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => 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 => {
                            TestAllTypesProto2Data::validate_until(
                                wire,
                                pos,
                                depth + 1,
                                Some(201),
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    204 => match w {
                        pbrs::rt::WIRE_SGROUP => {
                            MultiWordGroupField::validate_until(wire, pos, depth + 1, Some(204))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    241 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    242 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    243 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    244 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    245 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    246 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    247 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    248 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    249 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    250 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    251 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    252 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    253 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    254 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    255 => match w {
                        pbrs::rt::WIRE_LEN => {
                            pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    401 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    402 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    403 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    404 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    405 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    406 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    407 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    408 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    409 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    410 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    411 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    412 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    413 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    414 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    415 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    416 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    417 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    418 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    500 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            TestAllTypesProto2MessageSetCorrect::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.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 !self.map_int32_nested_message.is_empty() {
                for (k, v) in self.map_int32_nested_message.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(103, inner);
                }
            }
            if !self.map_int32_bool.is_empty() {
                for (k, v) in self.map_int32_bool.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(u64::from(*v));
                    n += pbrs::rt::key_len_value_len(104, inner);
                }
            }
            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.groupfield {
                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(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.data {
                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.multiwordgroupfield {
                n += pbrs::rt::tag_len(204, pbrs::rt::WIRE_SGROUP)
                    + m.compute_size()
                    + pbrs::rt::tag_len(204, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(v) = self.default_int32 {
                n += pbrs::rt::tag_len(241, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.default_int64 {
                n += pbrs::rt::tag_len(242, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.default_uint32 {
                n += pbrs::rt::tag_len(243, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.default_uint64 {
                n += pbrs::rt::tag_len(244, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.default_sint32 {
                n += pbrs::rt::tag_len(245, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(v));
            }
            if let Some(v) = self.default_sint64 {
                n += pbrs::rt::tag_len(246, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(v));
            }
            if let Some(v) = self.default_fixed32 {
                n += pbrs::rt::tag_len(247, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.default_fixed64 {
                n += pbrs::rt::tag_len(248, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.default_sfixed32 {
                n += pbrs::rt::tag_len(249, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.default_sfixed64 {
                n += pbrs::rt::tag_len(250, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.default_float {
                n += pbrs::rt::tag_len(251, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.default_double {
                n += pbrs::rt::tag_len(252, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.default_bool.get() {
                n += pbrs::rt::tag_len(253, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(u64::from(v));
            }
            if let Some(s) = &self.default_string {
                n += pbrs::rt::key_len_value_len(254, s.as_bytes().len() as u64);
            }
            if let Some(s) = &self.default_bytes {
                n += pbrs::rt::key_len_value_len(255, s.as_bytes().len() as u64);
            }
            if let Some(v) = self.fieldname1 {
                n += pbrs::rt::tag_len(401, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.field_name2 {
                n += pbrs::rt::tag_len(402, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self._field_name3 {
                n += pbrs::rt::tag_len(403, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.field__name4_ {
                n += pbrs::rt::tag_len(404, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.field0name5 {
                n += pbrs::rt::tag_len(405, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.field_0_name6 {
                n += pbrs::rt::tag_len(406, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.fieldName7 {
                n += pbrs::rt::tag_len(407, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.FieldName8 {
                n += pbrs::rt::tag_len(408, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.field_Name9 {
                n += pbrs::rt::tag_len(409, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.Field_Name10 {
                n += pbrs::rt::tag_len(410, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.FIELD_NAME11 {
                n += pbrs::rt::tag_len(411, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.FIELD_name12 {
                n += pbrs::rt::tag_len(412, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.__field_name13 {
                n += pbrs::rt::tag_len(413, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.__Field_name14 {
                n += pbrs::rt::tag_len(414, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.field__name15 {
                n += pbrs::rt::tag_len(415, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.field__Name16 {
                n += pbrs::rt::tag_len(416, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.field_name17__ {
                n += pbrs::rt::tag_len(417, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.Field_name18__ {
                n += pbrs::rt::tag_len(418, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(p) = self.message_set_correct.wire_bytes() {
                n += pbrs::rt::key_len_value_len(500, p.len() as u64);
            } else if let Some(m) = self.message_set_correct.as_deref() {
                n += pbrs::rt::key_len_value_len(500, m.compute_size());
            }
            if let Some(c) = self.cold.as_deref() {
                for t in c.repeated_int32.iter() {
                    n += pbrs::rt::tag_len(31, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.repeated_int64.iter() {
                    n += pbrs::rt::tag_len(32, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.repeated_uint32.iter() {
                    n += pbrs::rt::tag_len(33, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.repeated_uint64.iter() {
                    n += pbrs::rt::tag_len(34, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.repeated_sint32.iter() {
                    n += pbrs::rt::tag_len(35, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*t));
                }
                for t in c.repeated_sint64.iter() {
                    n += pbrs::rt::tag_len(36, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*t));
                }
                for t in c.repeated_fixed32.iter() {
                    n += pbrs::rt::tag_len(37, pbrs::rt::WIRE_I32) + 4;
                }
                for t in c.repeated_fixed64.iter() {
                    n += pbrs::rt::tag_len(38, pbrs::rt::WIRE_I64) + 8;
                }
                for t in c.repeated_sfixed32.iter() {
                    n += pbrs::rt::tag_len(39, pbrs::rt::WIRE_I32) + 4;
                }
                for t in c.repeated_sfixed64.iter() {
                    n += pbrs::rt::tag_len(40, pbrs::rt::WIRE_I64) + 8;
                }
                for t in c.repeated_float.iter() {
                    n += pbrs::rt::tag_len(41, pbrs::rt::WIRE_I32) + 4;
                }
                for t in c.repeated_double.iter() {
                    n += pbrs::rt::tag_len(42, pbrs::rt::WIRE_I64) + 8;
                }
                for t in c.repeated_bool.iter() {
                    n += pbrs::rt::tag_len(43, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*t));
                }
                for t in c.repeated_foreign_message.iter() {
                    n += pbrs::rt::key_len_value_len(49, t.compute_size());
                }
                for t in c.repeated_nested_enum.iter() {
                    n += pbrs::rt::tag_len(51, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.repeated_foreign_enum.iter() {
                    n += pbrs::rt::tag_len(52, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                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 !self.map_int32_nested_message.is_empty() {
                for (k, v) in self.map_int32_nested_message.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, 103, 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 !self.map_int32_bool.is_empty() {
                for (k, v) in self.map_int32_bool.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(u64::from(*v));
                    pbrs::rt::encode_tag(out, 104, 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, u64::from(*v));
                }
            }
            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.groupfield {
                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(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.data {
                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.multiwordgroupfield {
                pbrs::rt::encode_tag(out, 204, pbrs::rt::WIRE_SGROUP);
                m.write_to(out);
                pbrs::rt::encode_tag(out, 204, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(v) = self.default_int32 {
                pbrs::rt::encode_tag(out, 241, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.default_int64 {
                pbrs::rt::encode_tag(out, 242, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.default_uint32 {
                pbrs::rt::encode_tag(out, 243, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.default_uint64 {
                pbrs::rt::encode_tag(out, 244, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.default_sint32 {
                pbrs::rt::encode_tag(out, 245, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(v));
            }
            if let Some(v) = self.default_sint64 {
                pbrs::rt::encode_tag(out, 246, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(v));
            }
            if let Some(v) = self.default_fixed32 {
                pbrs::rt::encode_tag(out, 247, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(v).to_le_bytes());
            }
            if let Some(v) = self.default_fixed64 {
                pbrs::rt::encode_tag(out, 248, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(v).to_le_bytes());
            }
            if let Some(v) = self.default_sfixed32 {
                pbrs::rt::encode_tag(out, 249, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&((v) as u32).to_le_bytes());
            }
            if let Some(v) = self.default_sfixed64 {
                pbrs::rt::encode_tag(out, 250, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&((v) as u64).to_le_bytes());
            }
            if let Some(v) = self.default_float {
                pbrs::rt::encode_tag(out, 251, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(v).to_bits().to_le_bytes());
            }
            if let Some(v) = self.default_double {
                pbrs::rt::encode_tag(out, 252, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(v).to_bits().to_le_bytes());
            }
            if let Some(v) = self.default_bool.get() {
                pbrs::rt::encode_tag(out, 253, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, u64::from(v));
            }
            if let Some(s) = &self.default_string {
                pbrs::rt::encode_len_field(out, 254, s.as_bytes());
            }
            if let Some(s) = &self.default_bytes {
                pbrs::rt::encode_len_field(out, 255, s.as_bytes());
            }
            if let Some(v) = self.fieldname1 {
                pbrs::rt::encode_tag(out, 401, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.field_name2 {
                pbrs::rt::encode_tag(out, 402, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self._field_name3 {
                pbrs::rt::encode_tag(out, 403, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.field__name4_ {
                pbrs::rt::encode_tag(out, 404, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.field0name5 {
                pbrs::rt::encode_tag(out, 405, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.field_0_name6 {
                pbrs::rt::encode_tag(out, 406, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.fieldName7 {
                pbrs::rt::encode_tag(out, 407, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.FieldName8 {
                pbrs::rt::encode_tag(out, 408, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.field_Name9 {
                pbrs::rt::encode_tag(out, 409, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.Field_Name10 {
                pbrs::rt::encode_tag(out, 410, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.FIELD_NAME11 {
                pbrs::rt::encode_tag(out, 411, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.FIELD_name12 {
                pbrs::rt::encode_tag(out, 412, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.__field_name13 {
                pbrs::rt::encode_tag(out, 413, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.__Field_name14 {
                pbrs::rt::encode_tag(out, 414, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.field__name15 {
                pbrs::rt::encode_tag(out, 415, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.field__Name16 {
                pbrs::rt::encode_tag(out, 416, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.field_name17__ {
                pbrs::rt::encode_tag(out, 417, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.Field_name18__ {
                pbrs::rt::encode_tag(out, 418, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(p) = self.message_set_correct.wire_bytes() {
                pbrs::rt::encode_len_header(out, 500, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.message_set_correct.as_deref() {
                pbrs::rt::encode_len_header(out, 500, m.compute_size());
                m.write_to(out);
            }
            if let Some(c) = self.cold.as_deref() {
                for t in c.repeated_int32.iter() {
                    pbrs::rt::encode_tag(out, 31, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.repeated_int64.iter() {
                    pbrs::rt::encode_tag(out, 32, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.repeated_uint32.iter() {
                    pbrs::rt::encode_tag(out, 33, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.repeated_uint64.iter() {
                    pbrs::rt::encode_tag(out, 34, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.repeated_sint32.iter() {
                    pbrs::rt::encode_tag(out, 35, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(*t));
                }
                for t in c.repeated_sint64.iter() {
                    pbrs::rt::encode_tag(out, 36, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(*t));
                }
                for t in c.repeated_fixed32.iter() {
                    pbrs::rt::encode_tag(out, 37, pbrs::rt::WIRE_I32);
                    (out).extend_from_slice(&(*t).to_le_bytes());
                }
                for t in c.repeated_fixed64.iter() {
                    pbrs::rt::encode_tag(out, 38, pbrs::rt::WIRE_I64);
                    (out).extend_from_slice(&(*t).to_le_bytes());
                }
                for t in c.repeated_sfixed32.iter() {
                    pbrs::rt::encode_tag(out, 39, pbrs::rt::WIRE_I32);
                    (out).extend_from_slice(&((*t) as u32).to_le_bytes());
                }
                for t in c.repeated_sfixed64.iter() {
                    pbrs::rt::encode_tag(out, 40, pbrs::rt::WIRE_I64);
                    (out).extend_from_slice(&((*t) as u64).to_le_bytes());
                }
                for t in c.repeated_float.iter() {
                    pbrs::rt::encode_tag(out, 41, pbrs::rt::WIRE_I32);
                    (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                }
                for t in c.repeated_double.iter() {
                    pbrs::rt::encode_tag(out, 42, pbrs::rt::WIRE_I64);
                    (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                }
                for t in c.repeated_bool.iter() {
                    pbrs::rt::encode_tag(out, 43, pbrs::rt::WIRE_VARINT);
                    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);
                }
                for t in c.repeated_nested_enum.iter() {
                    pbrs::rt::encode_tag(out, 51, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.repeated_foreign_enum.iter() {
                    pbrs::rt::encode_tag(out, 52, pbrs::rt::WIRE_VARINT);
                    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.proto2.TestAllTypesProto2")
                .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.proto2.TestAllTypesProto2")
                .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.proto2.TestAllTypesProto2")
                .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.proto2.TestAllTypesProto2")
                .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.proto2.TestAllTypesProto2")
                .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!(
        TestAllTypesProto2,
        TestAllTypesProto2View,
        TestAllTypesProto2Mut
    );
    fn decode_map_entry_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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_TestAllTypesProto2_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)?;
                    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::LazyStr::from_span(wire, s, e);
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesProto2_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)?;
                    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(wire.window(s, e));
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesProto2_map_string_nested_message_71(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, TestAllTypesProto2NestedMessage), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = TestAllTypesProto2NestedMessage::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)?;
                    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_TestAllTypesProto2_map_string_foreign_message_72(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, ForeignMessageProto2), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = ForeignMessageProto2::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)?;
                    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_TestAllTypesProto2_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)?;
                    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_TestAllTypesProto2_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)?;
                    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_TestAllTypesProto2_map_int32_nested_message_103(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(i32, TestAllTypesProto2NestedMessage), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = i32::default();
        let mut val = TestAllTypesProto2NestedMessage::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))
    }
    fn decode_map_entry_TestAllTypesProto2_map_int32_bool_104(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(i32, bool), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = i32::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)? as i32,
                (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))
    }
    #[derive(Clone, Debug)]
    pub struct TestAllTypesProto2Data {
        group_int32: Option<i32>,
        group_uint32: Option<u32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for TestAllTypesProto2Data {
        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 TestAllTypesProto2Data {}
    impl Default for TestAllTypesProto2Data {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl TestAllTypesProto2Data {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.TestAllTypesProto2.Data";
        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.proto2.TestAllTypesProto2.Data")
                .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.proto2.TestAllTypesProto2.Data")
                .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.proto2.TestAllTypesProto2.Data")
                .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.proto2.TestAllTypesProto2.Data")
                .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.proto2.TestAllTypesProto2.Data")
                .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!(
        TestAllTypesProto2Data,
        TestAllTypesProto2DataView,
        TestAllTypesProto2DataMut
    );
    #[derive(Clone, Debug)]
    pub struct ExtensionWithOneof {
        a: Option<i32>,
        b: Option<i32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for ExtensionWithOneof {
        fn eq(&self, other: &Self) -> bool {
            if self.a != other.a {
                return false;
            }
            if self.b != other.b {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for ExtensionWithOneof {}
    impl Default for ExtensionWithOneof {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl ExtensionWithOneof {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllTypesProto2.ExtensionWithOneof";
        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.b = None;
            self.a = Some(v);
        }
        pub fn clear_a(&mut self) {
            self.cached_size.dirty();
            self.a = None;
        }
        pub fn has_b(&self) -> bool {
            self.b.is_some()
        }
        pub fn b(&self) -> i32 {
            self.b.unwrap_or(0)
        }
        pub fn b_opt(&self) -> Option<i32> {
            self.b.map(|v| v)
        }
        pub fn set_b(&mut self, v: i32) {
            self.cached_size.dirty();
            self.a = None;
            self.b = Some(v);
        }
        pub fn clear_b(&mut self) {
            self.cached_size.dirty();
            self.b = 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.b = None;
                            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_VARINT => {
                            self.a = None;
                            self.b = 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)?,
                    },
                    2 => 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.a {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.b {
                n += pbrs::rt::tag_len(2, 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.a {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.b {
                pbrs::rt::encode_tag(out, 2, 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.proto2.TestAllTypesProto2.ExtensionWithOneof")
                .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.proto2.TestAllTypesProto2.ExtensionWithOneof")
                .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.proto2.TestAllTypesProto2.ExtensionWithOneof")
                .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.proto2.TestAllTypesProto2.ExtensionWithOneof")
                .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.proto2.TestAllTypesProto2.ExtensionWithOneof")
                .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!(
        ExtensionWithOneof,
        ExtensionWithOneofView,
        ExtensionWithOneofMut
    );
    #[derive(Clone, Debug)]
    pub struct TestAllTypesProto2MessageSetCorrect {
        message_set_extension: pbrs::rt::LazyMsg<TestAllTypesProto2MessageSetCorrectExtension1>,
        message_set_extension_4135312:
            pbrs::rt::LazyMsg<TestAllTypesProto2MessageSetCorrectExtension2>,
        extension_with_oneof: pbrs::rt::LazyMsg<ExtensionWithOneof>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for TestAllTypesProto2MessageSetCorrect {
        fn eq(&self, other: &Self) -> bool {
            if self.message_set_extension != other.message_set_extension {
                return false;
            }
            if self.message_set_extension_4135312 != other.message_set_extension_4135312 {
                return false;
            }
            if self.extension_with_oneof != other.extension_with_oneof {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for TestAllTypesProto2MessageSetCorrect {}
    impl Default for TestAllTypesProto2MessageSetCorrect {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl TestAllTypesProto2MessageSetCorrect {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrect";
        pub fn has_message_set_extension(&self) -> bool {
            self.message_set_extension.is_some()
        }
        pub fn message_set_extension(&self) -> &TestAllTypesProto2MessageSetCorrectExtension1 {
            self.message_set_extension
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn message_set_extension_opt(
            &self,
        ) -> Option<&TestAllTypesProto2MessageSetCorrectExtension1> {
            self.message_set_extension.as_deref()
        }
        pub fn message_set_extension_view(
            &self,
        ) -> TestAllTypesProto2MessageSetCorrectExtension1View<'_> {
            TestAllTypesProto2MessageSetCorrectExtension1View(self.message_set_extension())
        }
        pub fn set_message_set_extension(
            &mut self,
            v: TestAllTypesProto2MessageSetCorrectExtension1,
        ) {
            self.cached_size.dirty();
            self.message_set_extension = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn message_set_extension_mut(
            &mut self,
        ) -> &mut TestAllTypesProto2MessageSetCorrectExtension1 {
            self.cached_size.dirty();
            self.message_set_extension.get_or_insert()
        }
        pub fn clear_message_set_extension(&mut self) {
            self.cached_size.dirty();
            self.message_set_extension.clear();
        }
        pub fn has_message_set_extension_4135312(&self) -> bool {
            self.message_set_extension_4135312.is_some()
        }
        pub fn message_set_extension_4135312(
            &self,
        ) -> &TestAllTypesProto2MessageSetCorrectExtension2 {
            self.message_set_extension_4135312
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn message_set_extension_4135312_opt(
            &self,
        ) -> Option<&TestAllTypesProto2MessageSetCorrectExtension2> {
            self.message_set_extension_4135312.as_deref()
        }
        pub fn message_set_extension_4135312_view(
            &self,
        ) -> TestAllTypesProto2MessageSetCorrectExtension2View<'_> {
            TestAllTypesProto2MessageSetCorrectExtension2View(self.message_set_extension_4135312())
        }
        pub fn set_message_set_extension_4135312(
            &mut self,
            v: TestAllTypesProto2MessageSetCorrectExtension2,
        ) {
            self.cached_size.dirty();
            self.message_set_extension_4135312 = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn message_set_extension_4135312_mut(
            &mut self,
        ) -> &mut TestAllTypesProto2MessageSetCorrectExtension2 {
            self.cached_size.dirty();
            self.message_set_extension_4135312.get_or_insert()
        }
        pub fn clear_message_set_extension_4135312(&mut self) {
            self.cached_size.dirty();
            self.message_set_extension_4135312.clear();
        }
        pub fn has_extension_with_oneof(&self) -> bool {
            self.extension_with_oneof.is_some()
        }
        pub fn extension_with_oneof(&self) -> &ExtensionWithOneof {
            self.extension_with_oneof
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn extension_with_oneof_opt(&self) -> Option<&ExtensionWithOneof> {
            self.extension_with_oneof.as_deref()
        }
        pub fn extension_with_oneof_view(&self) -> ExtensionWithOneofView<'_> {
            ExtensionWithOneofView(self.extension_with_oneof())
        }
        pub fn set_extension_with_oneof(&mut self, v: ExtensionWithOneof) {
            self.cached_size.dirty();
            self.extension_with_oneof = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn extension_with_oneof_mut(&mut self) -> &mut ExtensionWithOneof {
            self.cached_size.dirty();
            self.extension_with_oneof.get_or_insert()
        }
        pub fn clear_extension_with_oneof(&mut self) {
            self.cached_size.dirty();
            self.extension_with_oneof.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_SGROUP | pbrs::rt::WIRE_LEN => {
                                let mut type_id = 0u32;
                                let mut payload: Vec<u8> = Vec::new();
                                if w == pbrs::rt::WIRE_LEN {
                                    let inner = pbrs::rt::read_len_bytes(data, pos)?;
                                    let mut p = 0;
                                    while p < inner.len() {
                                        let (n, ww) = pbrs::rt::decode_tag(inner, &mut p)?;
                                        match (n, ww) {
                                            (2, pbrs::rt::WIRE_VARINT) => {
                                                type_id =
                                                    pbrs::rt::decode_varint(inner, &mut p)? as u32
                                            }
                                            (3, pbrs::rt::WIRE_LEN) => {
                                                payload = pbrs::rt::read_len_bytes(inner, &mut p)?
                                                    .to_vec()
                                            }
                                            _ => pbrs::rt::skip_field(inner, &mut p, ww)?,
                                        }
                                    }
                                } else {
                                    loop {
                                        let (n, ww) = pbrs::rt::decode_tag(data, pos)?;
                                        if ww == pbrs::rt::WIRE_EGROUP && n == 1 {
                                            break;
                                        }
                                        match (n, ww) {
                                            (2, pbrs::rt::WIRE_VARINT) => {
                                                type_id = pbrs::rt::decode_varint(data, pos)? as u32
                                            }
                                            (3, pbrs::rt::WIRE_LEN) => {
                                                payload =
                                                    pbrs::rt::read_len_bytes(data, pos)?.to_vec()
                                            }
                                            _ => pbrs::rt::skip_field(data, pos, ww)?,
                                        }
                                    }
                                }
                                match type_id {
                                    1547769 => {
                                        if self.message_set_extension.is_some() {
                                            self.message_set_extension
                                                .get_or_insert()
                                                .merge_bytes(&payload, depth + 1)?;
                                        } else {
                                            let mut inner = TestAllTypesProto2MessageSetCorrectExtension1::default();
                                            inner.merge_bytes(&payload, depth + 1)?;
                                            self.message_set_extension =
                                                pbrs::rt::LazyMsg::from_owned(inner);
                                        }
                                    }
                                    4135312 => {
                                        if self.message_set_extension_4135312.is_some() {
                                            self.message_set_extension_4135312
                                                .get_or_insert()
                                                .merge_bytes(&payload, depth + 1)?;
                                        } else {
                                            let mut inner = TestAllTypesProto2MessageSetCorrectExtension2::default();
                                            inner.merge_bytes(&payload, depth + 1)?;
                                            self.message_set_extension_4135312 =
                                                pbrs::rt::LazyMsg::from_owned(inner);
                                        }
                                    }
                                    123456789 => {
                                        if self.extension_with_oneof.is_some() {
                                            self.extension_with_oneof
                                                .get_or_insert()
                                                .merge_bytes(&payload, depth + 1)?;
                                        } else {
                                            let mut inner = ExtensionWithOneof::default();
                                            inner.merge_bytes(&payload, depth + 1)?;
                                            self.extension_with_oneof =
                                                pbrs::rt::LazyMsg::from_owned(inner);
                                        }
                                    }
                                    _ => {
                                        let mut u = pbrs::UnknownFields::default();
                                        u.fields.push(pbrs::rt::UnknownField::Varint {
                                            number: 2,
                                            value: u64::from(type_id),
                                        });
                                        u.fields.push(pbrs::rt::UnknownField::LengthDelimited {
                                            number: 3,
                                            value: payload,
                                        });
                                        self.unknown.fields.push(pbrs::rt::UnknownField::Group {
                                            number: 1,
                                            fields: u,
                                        });
                                    }
                                }
                            }
                            _ => self
                                .unknown
                                .fields
                                .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                        }
                    }
                    1547769 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.message_set_extension.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.message_set_extension.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                TestAllTypesProto2MessageSetCorrectExtension1::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.message_set_extension = 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)?),
                    },
                    4135312 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.message_set_extension_4135312.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.message_set_extension_4135312
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                TestAllTypesProto2MessageSetCorrectExtension2::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.message_set_extension_4135312 = 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)?),
                    },
                    123456789 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.extension_with_oneof.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.extension_with_oneof.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                ExtensionWithOneof::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.extension_with_oneof = 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 {
                    1547769 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            TestAllTypesProto2MessageSetCorrectExtension1::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    4135312 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            TestAllTypesProto2MessageSetCorrectExtension2::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    123456789 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            ExtensionWithOneof::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(m) = self.message_set_extension.as_deref() {
                let inner = m.compute_size();
                let item = pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(1547769 as u64)
                    + pbrs::rt::key_len_value_len(3, inner);
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_SGROUP)
                    + item
                    + pbrs::rt::tag_len(1, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(m) = self.message_set_extension_4135312.as_deref() {
                let inner = m.compute_size();
                let item = pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(4135312 as u64)
                    + pbrs::rt::key_len_value_len(3, inner);
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_SGROUP)
                    + item
                    + pbrs::rt::tag_len(1, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(m) = self.extension_with_oneof.as_deref() {
                let inner = m.compute_size();
                let item = pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(123456789 as u64)
                    + pbrs::rt::key_len_value_len(3, inner);
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_SGROUP)
                    + item
                    + pbrs::rt::tag_len(1, pbrs::rt::WIRE_EGROUP);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(m) = self.message_set_extension.as_deref() {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_SGROUP);
                pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, 1547769 as u64);
                pbrs::rt::encode_len_header(out, 3, m.compute_size());
                m.write_to(out);
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(m) = self.message_set_extension_4135312.as_deref() {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_SGROUP);
                pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, 4135312 as u64);
                pbrs::rt::encode_len_header(out, 3, m.compute_size());
                m.write_to(out);
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(m) = self.extension_with_oneof.as_deref() {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_SGROUP);
                pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, 123456789 as u64);
                pbrs::rt::encode_len_header(out, 3, m.compute_size());
                m.write_to(out);
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_EGROUP);
            }
            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.proto2.TestAllTypesProto2.MessageSetCorrect")
                .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.proto2.TestAllTypesProto2.MessageSetCorrect")
                .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.proto2.TestAllTypesProto2.MessageSetCorrect")
                .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.proto2.TestAllTypesProto2.MessageSetCorrect")
                .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.proto2.TestAllTypesProto2.MessageSetCorrect")
                .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!(
        TestAllTypesProto2MessageSetCorrect,
        TestAllTypesProto2MessageSetCorrectView,
        TestAllTypesProto2MessageSetCorrectMut
    );
    #[derive(Clone, Debug)]
    pub struct TestAllTypesProto2MessageSetCorrectExtension1 {
        str: Option<Box<pbrs::rt::LazyStr>>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for TestAllTypesProto2MessageSetCorrectExtension1 {
        fn eq(&self, other: &Self) -> bool {
            if self.str != other.str {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for TestAllTypesProto2MessageSetCorrectExtension1 {}
    impl Default for TestAllTypesProto2MessageSetCorrectExtension1 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl TestAllTypesProto2MessageSetCorrectExtension1 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1";
        pub fn has_str(&self) -> bool {
            self.str.is_some()
        }
        pub fn str(&self) -> &pbrs::ProtoStr {
            self.str
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn str_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.str.as_ref().map(|s| s.as_view())
        }
        pub fn set_str(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.str = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_str(&mut self) {
            self.cached_size.dirty();
            self.str = 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 {
                    25 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            self.str = 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)?),
                    },
                    _ => 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 {
                    25 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => 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(s) = &self.str {
                n += pbrs::rt::key_len_value_len(25, s.as_bytes().len() as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(s) = &self.str {
                pbrs::rt::encode_len_field(out, 25, s.as_bytes());
            }
            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.proto2.TestAllTypesProto2.MessageSetCorrectExtension1",
                )
                .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.proto2.TestAllTypesProto2.MessageSetCorrectExtension1",
                )
                .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.proto2.TestAllTypesProto2.MessageSetCorrectExtension1",
                )
                .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.proto2.TestAllTypesProto2.MessageSetCorrectExtension1",
                )
                .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.proto2.TestAllTypesProto2.MessageSetCorrectExtension1",
                )
                .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!(
        TestAllTypesProto2MessageSetCorrectExtension1,
        TestAllTypesProto2MessageSetCorrectExtension1View,
        TestAllTypesProto2MessageSetCorrectExtension1Mut
    );
    #[derive(Clone, Debug)]
    pub struct TestAllTypesProto2MessageSetCorrectExtension2 {
        i: Option<i32>,
        sub_msg: pbrs::rt::LazyMsg<TestAllTypesProto2MessageSetCorrect>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for TestAllTypesProto2MessageSetCorrectExtension2 {
        fn eq(&self, other: &Self) -> bool {
            if self.i != other.i {
                return false;
            }
            if self.sub_msg != other.sub_msg {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for TestAllTypesProto2MessageSetCorrectExtension2 {}
    impl Default for TestAllTypesProto2MessageSetCorrectExtension2 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl TestAllTypesProto2MessageSetCorrectExtension2 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2";
        pub fn has_i(&self) -> bool {
            self.i.is_some()
        }
        pub fn i(&self) -> i32 {
            self.i.unwrap_or(0)
        }
        pub fn i_opt(&self) -> Option<i32> {
            self.i.map(|v| v)
        }
        pub fn set_i(&mut self, v: i32) {
            self.cached_size.dirty();
            self.i = Some(v);
        }
        pub fn clear_i(&mut self) {
            self.cached_size.dirty();
            self.i = None;
        }
        pub fn has_sub_msg(&self) -> bool {
            self.sub_msg.is_some()
        }
        pub fn sub_msg(&self) -> &TestAllTypesProto2MessageSetCorrect {
            self.sub_msg
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn sub_msg_opt(&self) -> Option<&TestAllTypesProto2MessageSetCorrect> {
            self.sub_msg.as_deref()
        }
        pub fn sub_msg_view(&self) -> TestAllTypesProto2MessageSetCorrectView<'_> {
            TestAllTypesProto2MessageSetCorrectView(self.sub_msg())
        }
        pub fn set_sub_msg(&mut self, v: TestAllTypesProto2MessageSetCorrect) {
            self.cached_size.dirty();
            self.sub_msg = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn sub_msg_mut(&mut self) -> &mut TestAllTypesProto2MessageSetCorrect {
            self.cached_size.dirty();
            self.sub_msg.get_or_insert()
        }
        pub fn clear_sub_msg(&mut self) {
            self.cached_size.dirty();
            self.sub_msg.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 {
                    9 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.i = Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    10 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.sub_msg.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.sub_msg.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                TestAllTypesProto2MessageSetCorrect::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.sub_msg = 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 {
                    9 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    10 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            TestAllTypesProto2MessageSetCorrect::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.i {
                n += pbrs::rt::tag_len(9, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(p) = self.sub_msg.wire_bytes() {
                n += pbrs::rt::key_len_value_len(10, p.len() as u64);
            } else if let Some(m) = self.sub_msg.as_deref() {
                n += pbrs::rt::key_len_value_len(10, m.compute_size());
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(v) = self.i {
                pbrs::rt::encode_tag(out, 9, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(p) = self.sub_msg.wire_bytes() {
                pbrs::rt::encode_len_header(out, 10, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.sub_msg.as_deref() {
                pbrs::rt::encode_len_header(out, 10, 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.proto2.TestAllTypesProto2.MessageSetCorrectExtension2",
                )
                .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.proto2.TestAllTypesProto2.MessageSetCorrectExtension2",
                )
                .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.proto2.TestAllTypesProto2.MessageSetCorrectExtension2",
                )
                .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.proto2.TestAllTypesProto2.MessageSetCorrectExtension2",
                )
                .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.proto2.TestAllTypesProto2.MessageSetCorrectExtension2",
                )
                .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!(
        TestAllTypesProto2MessageSetCorrectExtension2,
        TestAllTypesProto2MessageSetCorrectExtension2View,
        TestAllTypesProto2MessageSetCorrectExtension2Mut
    );
    #[derive(Clone, Debug)]
    pub struct MultiWordGroupField {
        group_int32: Option<i32>,
        group_uint32: Option<u32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for MultiWordGroupField {
        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 MultiWordGroupField {}
    impl Default for MultiWordGroupField {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl MultiWordGroupField {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField";
        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 {
                    205 => 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)?),
                    },
                    206 => 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 {
                    205 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    206 => 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(205, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.group_uint32 {
                n += pbrs::rt::tag_len(206, 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, 205, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.group_uint32 {
                pbrs::rt::encode_tag(out, 206, 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.proto2.TestAllTypesProto2.MultiWordGroupField")
                .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.proto2.TestAllTypesProto2.MultiWordGroupField")
                .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.proto2.TestAllTypesProto2.MultiWordGroupField")
                .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.proto2.TestAllTypesProto2.MultiWordGroupField")
                .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.proto2.TestAllTypesProto2.MultiWordGroupField")
                .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!(
        MultiWordGroupField,
        MultiWordGroupFieldView,
        MultiWordGroupFieldMut
    );
    #[derive(Clone, Debug)]
    pub struct TestAllTypesProto2NestedMessage {
        a: Option<i32>,
        corecursive: pbrs::rt::LazyMsg<TestAllTypesProto2>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for TestAllTypesProto2NestedMessage {
        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 TestAllTypesProto2NestedMessage {}
    impl Default for TestAllTypesProto2NestedMessage {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl TestAllTypesProto2NestedMessage {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.TestAllTypesProto2.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) -> &TestAllTypesProto2 {
            self.corecursive
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn corecursive_opt(&self) -> Option<&TestAllTypesProto2> {
            self.corecursive.as_deref()
        }
        pub fn corecursive_view(&self) -> TestAllTypesProto2View<'_> {
            TestAllTypesProto2View(self.corecursive())
        }
        pub fn set_corecursive(&mut self, v: TestAllTypesProto2) {
            self.cached_size.dirty();
            self.corecursive = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn corecursive_mut(&mut self) -> &mut TestAllTypesProto2 {
            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;
                                TestAllTypesProto2::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;
                            TestAllTypesProto2::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.proto2.TestAllTypesProto2.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.proto2.TestAllTypesProto2.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.proto2.TestAllTypesProto2.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.proto2.TestAllTypesProto2.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.proto2.TestAllTypesProto2.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!(
        TestAllTypesProto2NestedMessage,
        TestAllTypesProto2NestedMessageView,
        TestAllTypesProto2NestedMessageMut
    );
    #[derive(Clone, Debug)]
    pub struct TestLargeOneof {
        a1: pbrs::rt::LazyMsg<A1>,
        a2: pbrs::rt::LazyMsg<A2>,
        a3: pbrs::rt::LazyMsg<A3>,
        a4: pbrs::rt::LazyMsg<A4>,
        a5: pbrs::rt::LazyMsg<A5>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for TestLargeOneof {
        fn eq(&self, other: &Self) -> bool {
            if self.a1 != other.a1 {
                return false;
            }
            if self.a2 != other.a2 {
                return false;
            }
            if self.a3 != other.a3 {
                return false;
            }
            if self.a4 != other.a4 {
                return false;
            }
            if self.a5 != other.a5 {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for TestLargeOneof {}
    impl Default for TestLargeOneof {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl TestLargeOneof {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.TestLargeOneof";
        pub fn has_a1(&self) -> bool {
            self.a1.is_some()
        }
        pub fn a1(&self) -> &A1 {
            self.a1
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn a1_opt(&self) -> Option<&A1> {
            self.a1.as_deref()
        }
        pub fn a1_view(&self) -> A1View<'_> {
            A1View(self.a1())
        }
        pub fn set_a1(&mut self, v: A1) {
            self.cached_size.dirty();
            self.a2 = Default::default();
            self.a3 = Default::default();
            self.a4 = Default::default();
            self.a5 = Default::default();
            self.a1 = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn a1_mut(&mut self) -> &mut A1 {
            self.cached_size.dirty();
            self.a1.get_or_insert()
        }
        pub fn clear_a1(&mut self) {
            self.cached_size.dirty();
            self.a1.clear();
        }
        pub fn has_a2(&self) -> bool {
            self.a2.is_some()
        }
        pub fn a2(&self) -> &A2 {
            self.a2
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn a2_opt(&self) -> Option<&A2> {
            self.a2.as_deref()
        }
        pub fn a2_view(&self) -> A2View<'_> {
            A2View(self.a2())
        }
        pub fn set_a2(&mut self, v: A2) {
            self.cached_size.dirty();
            self.a1 = Default::default();
            self.a3 = Default::default();
            self.a4 = Default::default();
            self.a5 = Default::default();
            self.a2 = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn a2_mut(&mut self) -> &mut A2 {
            self.cached_size.dirty();
            self.a2.get_or_insert()
        }
        pub fn clear_a2(&mut self) {
            self.cached_size.dirty();
            self.a2.clear();
        }
        pub fn has_a3(&self) -> bool {
            self.a3.is_some()
        }
        pub fn a3(&self) -> &A3 {
            self.a3
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn a3_opt(&self) -> Option<&A3> {
            self.a3.as_deref()
        }
        pub fn a3_view(&self) -> A3View<'_> {
            A3View(self.a3())
        }
        pub fn set_a3(&mut self, v: A3) {
            self.cached_size.dirty();
            self.a1 = Default::default();
            self.a2 = Default::default();
            self.a4 = Default::default();
            self.a5 = Default::default();
            self.a3 = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn a3_mut(&mut self) -> &mut A3 {
            self.cached_size.dirty();
            self.a3.get_or_insert()
        }
        pub fn clear_a3(&mut self) {
            self.cached_size.dirty();
            self.a3.clear();
        }
        pub fn has_a4(&self) -> bool {
            self.a4.is_some()
        }
        pub fn a4(&self) -> &A4 {
            self.a4
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn a4_opt(&self) -> Option<&A4> {
            self.a4.as_deref()
        }
        pub fn a4_view(&self) -> A4View<'_> {
            A4View(self.a4())
        }
        pub fn set_a4(&mut self, v: A4) {
            self.cached_size.dirty();
            self.a1 = Default::default();
            self.a2 = Default::default();
            self.a3 = Default::default();
            self.a5 = Default::default();
            self.a4 = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn a4_mut(&mut self) -> &mut A4 {
            self.cached_size.dirty();
            self.a4.get_or_insert()
        }
        pub fn clear_a4(&mut self) {
            self.cached_size.dirty();
            self.a4.clear();
        }
        pub fn has_a5(&self) -> bool {
            self.a5.is_some()
        }
        pub fn a5(&self) -> &A5 {
            self.a5
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn a5_opt(&self) -> Option<&A5> {
            self.a5.as_deref()
        }
        pub fn a5_view(&self) -> A5View<'_> {
            A5View(self.a5())
        }
        pub fn set_a5(&mut self, v: A5) {
            self.cached_size.dirty();
            self.a1 = Default::default();
            self.a2 = Default::default();
            self.a3 = Default::default();
            self.a4 = Default::default();
            self.a5 = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn a5_mut(&mut self) -> &mut A5 {
            self.cached_size.dirty();
            self.a5.get_or_insert()
        }
        pub fn clear_a5(&mut self) {
            self.cached_size.dirty();
            self.a5.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_LEN => {
                            self.a2 = Default::default();
                            self.a3 = Default::default();
                            self.a4 = Default::default();
                            self.a5 = Default::default();
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.a1.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.a1.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                A1::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.a1 = 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)?),
                    },
                    2 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.a1 = Default::default();
                            self.a3 = Default::default();
                            self.a4 = Default::default();
                            self.a5 = Default::default();
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.a2.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.a2.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                A2::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.a2 = 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)?),
                    },
                    3 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.a1 = Default::default();
                            self.a2 = Default::default();
                            self.a4 = Default::default();
                            self.a5 = Default::default();
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.a3.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.a3.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                A3::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.a3 = 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)?),
                    },
                    4 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.a1 = Default::default();
                            self.a2 = Default::default();
                            self.a3 = Default::default();
                            self.a5 = Default::default();
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.a4.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.a4.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                A4::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.a4 = 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)?),
                    },
                    5 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.a1 = Default::default();
                            self.a2 = Default::default();
                            self.a3 = Default::default();
                            self.a4 = Default::default();
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.a5.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.a5.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                A5::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.a5 = 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_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            A1::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => 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;
                            A2::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    3 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            A3::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    4 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            A4::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    5 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            A5::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(p) = self.a1.wire_bytes() {
                n += pbrs::rt::key_len_value_len(1, p.len() as u64);
            } else if let Some(m) = self.a1.as_deref() {
                n += pbrs::rt::key_len_value_len(1, m.compute_size());
            }
            if let Some(p) = self.a2.wire_bytes() {
                n += pbrs::rt::key_len_value_len(2, p.len() as u64);
            } else if let Some(m) = self.a2.as_deref() {
                n += pbrs::rt::key_len_value_len(2, m.compute_size());
            }
            if let Some(p) = self.a3.wire_bytes() {
                n += pbrs::rt::key_len_value_len(3, p.len() as u64);
            } else if let Some(m) = self.a3.as_deref() {
                n += pbrs::rt::key_len_value_len(3, m.compute_size());
            }
            if let Some(p) = self.a4.wire_bytes() {
                n += pbrs::rt::key_len_value_len(4, p.len() as u64);
            } else if let Some(m) = self.a4.as_deref() {
                n += pbrs::rt::key_len_value_len(4, m.compute_size());
            }
            if let Some(p) = self.a5.wire_bytes() {
                n += pbrs::rt::key_len_value_len(5, p.len() as u64);
            } else if let Some(m) = self.a5.as_deref() {
                n += pbrs::rt::key_len_value_len(5, m.compute_size());
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(p) = self.a1.wire_bytes() {
                pbrs::rt::encode_len_header(out, 1, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.a1.as_deref() {
                pbrs::rt::encode_len_header(out, 1, m.compute_size());
                m.write_to(out);
            }
            if let Some(p) = self.a2.wire_bytes() {
                pbrs::rt::encode_len_header(out, 2, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.a2.as_deref() {
                pbrs::rt::encode_len_header(out, 2, m.compute_size());
                m.write_to(out);
            }
            if let Some(p) = self.a3.wire_bytes() {
                pbrs::rt::encode_len_header(out, 3, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.a3.as_deref() {
                pbrs::rt::encode_len_header(out, 3, m.compute_size());
                m.write_to(out);
            }
            if let Some(p) = self.a4.wire_bytes() {
                pbrs::rt::encode_len_header(out, 4, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.a4.as_deref() {
                pbrs::rt::encode_len_header(out, 4, m.compute_size());
                m.write_to(out);
            }
            if let Some(p) = self.a5.wire_bytes() {
                pbrs::rt::encode_len_header(out, 5, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.a5.as_deref() {
                pbrs::rt::encode_len_header(out, 5, 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.proto2.TestLargeOneof")
                .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.proto2.TestLargeOneof")
                .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.proto2.TestLargeOneof")
                .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.proto2.TestLargeOneof")
                .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.proto2.TestLargeOneof")
                .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!(TestLargeOneof, TestLargeOneofView, TestLargeOneofMut);
    #[derive(Clone, Debug)]
    pub struct A1 {
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for A1 {
        fn eq(&self, other: &Self) -> bool {
            self.unknown == other.unknown
        }
    }
    impl Eq for A1 {}
    impl Default for A1 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl A1 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.TestLargeOneof.A1";
        #[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 {
                    _ => 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 {
                    _ => 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();
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            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.proto2.TestLargeOneof.A1")
                .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.proto2.TestLargeOneof.A1")
                .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.proto2.TestLargeOneof.A1")
                .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.proto2.TestLargeOneof.A1")
                .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.proto2.TestLargeOneof.A1")
                .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!(A1, A1View, A1Mut);
    #[derive(Clone, Debug)]
    pub struct A2 {
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for A2 {
        fn eq(&self, other: &Self) -> bool {
            self.unknown == other.unknown
        }
    }
    impl Eq for A2 {}
    impl Default for A2 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl A2 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.TestLargeOneof.A2";
        #[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 {
                    _ => 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 {
                    _ => 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();
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            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.proto2.TestLargeOneof.A2")
                .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.proto2.TestLargeOneof.A2")
                .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.proto2.TestLargeOneof.A2")
                .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.proto2.TestLargeOneof.A2")
                .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.proto2.TestLargeOneof.A2")
                .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!(A2, A2View, A2Mut);
    #[derive(Clone, Debug)]
    pub struct A3 {
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for A3 {
        fn eq(&self, other: &Self) -> bool {
            self.unknown == other.unknown
        }
    }
    impl Eq for A3 {}
    impl Default for A3 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl A3 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.TestLargeOneof.A3";
        #[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 {
                    _ => 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 {
                    _ => 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();
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            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.proto2.TestLargeOneof.A3")
                .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.proto2.TestLargeOneof.A3")
                .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.proto2.TestLargeOneof.A3")
                .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.proto2.TestLargeOneof.A3")
                .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.proto2.TestLargeOneof.A3")
                .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!(A3, A3View, A3Mut);
    #[derive(Clone, Debug)]
    pub struct A4 {
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for A4 {
        fn eq(&self, other: &Self) -> bool {
            self.unknown == other.unknown
        }
    }
    impl Eq for A4 {}
    impl Default for A4 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl A4 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.TestLargeOneof.A4";
        #[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 {
                    _ => 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 {
                    _ => 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();
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            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.proto2.TestLargeOneof.A4")
                .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.proto2.TestLargeOneof.A4")
                .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.proto2.TestLargeOneof.A4")
                .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.proto2.TestLargeOneof.A4")
                .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.proto2.TestLargeOneof.A4")
                .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!(A4, A4View, A4Mut);
    #[derive(Clone, Debug)]
    pub struct A5 {
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for A5 {
        fn eq(&self, other: &Self) -> bool {
            self.unknown == other.unknown
        }
    }
    impl Eq for A5 {}
    impl Default for A5 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl A5 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.TestLargeOneof.A5";
        #[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 {
                    _ => 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 {
                    _ => 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();
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            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.proto2.TestLargeOneof.A5")
                .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.proto2.TestLargeOneof.A5")
                .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.proto2.TestLargeOneof.A5")
                .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.proto2.TestLargeOneof.A5")
                .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.proto2.TestLargeOneof.A5")
                .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!(A5, A5View, A5Mut);
    #[derive(Clone, Debug)]
    pub struct UnknownToTestAllTypes {
        optional_int32: Option<i32>,
        optional_string: Option<Box<pbrs::rt::LazyStr>>,
        nested_message: pbrs::rt::LazyMsg<ForeignMessageProto2>,
        optionalgroup: Option<Box<OptionalGroup>>,
        optional_bool: pbrs::rt::OptBool,
        repeated_int32: Repeated<i32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for UnknownToTestAllTypes {
        fn eq(&self, other: &Self) -> bool {
            if self.optional_int32 != other.optional_int32 {
                return false;
            }
            if self.optional_string != other.optional_string {
                return false;
            }
            if self.nested_message != other.nested_message {
                return false;
            }
            if self.optionalgroup != other.optionalgroup {
                return false;
            }
            if self.optional_bool != other.optional_bool {
                return false;
            }
            if self.repeated_int32 != other.repeated_int32 {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for UnknownToTestAllTypes {}
    impl Default for UnknownToTestAllTypes {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl UnknownToTestAllTypes {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto2.UnknownToTestAllTypes";
        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_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 has_nested_message(&self) -> bool {
            self.nested_message.is_some()
        }
        pub fn nested_message(&self) -> &ForeignMessageProto2 {
            self.nested_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn nested_message_opt(&self) -> Option<&ForeignMessageProto2> {
            self.nested_message.as_deref()
        }
        pub fn nested_message_view(&self) -> ForeignMessageProto2View<'_> {
            ForeignMessageProto2View(self.nested_message())
        }
        pub fn set_nested_message(&mut self, v: ForeignMessageProto2) {
            self.cached_size.dirty();
            self.nested_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn nested_message_mut(&mut self) -> &mut ForeignMessageProto2 {
            self.cached_size.dirty();
            self.nested_message.get_or_insert()
        }
        pub fn clear_nested_message(&mut self) {
            self.cached_size.dirty();
            self.nested_message.clear();
        }
        pub fn has_optionalgroup(&self) -> bool {
            self.optionalgroup.is_some()
        }
        pub fn optionalgroup(&self) -> &OptionalGroup {
            self.optionalgroup
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optionalgroup_opt(&self) -> Option<&OptionalGroup> {
            self.optionalgroup.as_deref()
        }
        pub fn optionalgroup_view(&self) -> OptionalGroupView<'_> {
            OptionalGroupView(self.optionalgroup())
        }
        pub fn set_optionalgroup(&mut self, v: OptionalGroup) {
            self.cached_size.dirty();
            self.optionalgroup = Some(Box::new(v));
        }
        pub fn optionalgroup_mut(&mut self) -> &mut OptionalGroup {
            self.cached_size.dirty();
            self.optionalgroup
                .get_or_insert_with(|| Box::new(OptionalGroup::default()))
                .as_mut()
        }
        pub fn clear_optionalgroup(&mut self) {
            self.cached_size.dirty();
            self.optionalgroup = 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 repeated_int32(&self) -> RepeatedView<'_, i32> {
            self.repeated_int32.as_view()
        }
        pub fn repeated_int32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.repeated_int32.as_mut()
        }
        pub fn set_repeated_int32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.repeated_int32 = v.into_iter().collect();
        }
        #[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 {
                    1001 => 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)?),
                    },
                    1002 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            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)?),
                    },
                    1003 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.nested_message.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.nested_message.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                ForeignMessageProto2::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.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)?),
                    },
                    1004 => match w {
                        pbrs::rt::WIRE_SGROUP => match &mut self.optionalgroup {
                            Some(existing) => {
                                existing.merge_group(data, wire, pos, 1004, depth + 1)?
                            }
                            None => {
                                let mut inner = OptionalGroup::default();
                                inner.merge_group(data, wire, pos, 1004, depth + 1)?;
                                self.optionalgroup = Some(Box::new(inner));
                            }
                        },
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    1006 => 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)?),
                    },
                    1011 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.repeated_int32
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as i32);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.repeated_int32
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.repeated_int32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 1011 && w2 == pbrs::rt::WIRE_VARINT => {
                                        self.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)?),
                    },
                    _ => 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 {
                    1001 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    1002 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    1003 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            ForeignMessageProto2::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    1004 => match w {
                        pbrs::rt::WIRE_SGROUP => {
                            OptionalGroup::validate_until(wire, pos, depth + 1, Some(1004))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    1006 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    1011 => 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)?,
                    },
                    _ => 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(1001, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(s) = &self.optional_string {
                n += pbrs::rt::key_len_value_len(1002, s.as_bytes().len() as u64);
            }
            if let Some(p) = self.nested_message.wire_bytes() {
                n += pbrs::rt::key_len_value_len(1003, p.len() as u64);
            } else if let Some(m) = self.nested_message.as_deref() {
                n += pbrs::rt::key_len_value_len(1003, m.compute_size());
            }
            if let Some(m) = &self.optionalgroup {
                n += pbrs::rt::tag_len(1004, pbrs::rt::WIRE_SGROUP)
                    + m.compute_size()
                    + pbrs::rt::tag_len(1004, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(v) = self.optional_bool.get() {
                n += pbrs::rt::tag_len(1006, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(u64::from(v));
            }
            for t in self.repeated_int32.iter() {
                n += pbrs::rt::tag_len(1011, 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, 1001, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(s) = &self.optional_string {
                pbrs::rt::encode_len_field(out, 1002, s.as_bytes());
            }
            if let Some(p) = self.nested_message.wire_bytes() {
                pbrs::rt::encode_len_header(out, 1003, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.nested_message.as_deref() {
                pbrs::rt::encode_len_header(out, 1003, m.compute_size());
                m.write_to(out);
            }
            if let Some(m) = &self.optionalgroup {
                pbrs::rt::encode_tag(out, 1004, pbrs::rt::WIRE_SGROUP);
                m.write_to(out);
                pbrs::rt::encode_tag(out, 1004, pbrs::rt::WIRE_EGROUP);
            }
            if let Some(v) = self.optional_bool.get() {
                pbrs::rt::encode_tag(out, 1006, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, u64::from(v));
            }
            for t in self.repeated_int32.iter() {
                pbrs::rt::encode_tag(out, 1011, 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.proto2.UnknownToTestAllTypes")
                .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.proto2.UnknownToTestAllTypes")
                .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.proto2.UnknownToTestAllTypes")
                .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.proto2.UnknownToTestAllTypes")
                .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.proto2.UnknownToTestAllTypes")
                .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!(
        UnknownToTestAllTypes,
        UnknownToTestAllTypesView,
        UnknownToTestAllTypesMut
    );
    #[derive(Clone, Debug)]
    pub struct OptionalGroup {
        a: Option<i32>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for OptionalGroup {
        fn eq(&self, other: &Self) -> bool {
            if self.a != other.a {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for OptionalGroup {}
    impl Default for OptionalGroup {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl OptionalGroup {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup";
        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;
        }
        #[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)?),
                    },
                    _ => 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.a {
                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.a {
                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.proto2.UnknownToTestAllTypes.OptionalGroup")
                .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.proto2.UnknownToTestAllTypes.OptionalGroup")
                .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.proto2.UnknownToTestAllTypes.OptionalGroup")
                .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.proto2.UnknownToTestAllTypes.OptionalGroup")
                .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.proto2.UnknownToTestAllTypes.OptionalGroup")
                .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!(OptionalGroup, OptionalGroupView, OptionalGroupMut);
    pub mod enum_only_proto2 {
        pub use super::Bool;
    }
    pub mod test_all_required_types_proto2 {
        pub use super::Data;
        pub use super::MessageSetCorrect;
        pub use super::MessageSetCorrectExtension1;
        pub use super::MessageSetCorrectExtension2;
        pub use super::NestedEnum;
        pub use super::NestedMessage;
    }
    pub mod test_all_types_proto2 {
        pub use super::ExtensionWithOneof;
        pub use super::MultiWordGroupField;
        pub use super::TestAllTypesProto2Data as Data;
        pub use super::TestAllTypesProto2MessageSetCorrect as MessageSetCorrect;
        pub use super::TestAllTypesProto2MessageSetCorrectExtension1 as MessageSetCorrectExtension1;
        pub use super::TestAllTypesProto2MessageSetCorrectExtension2 as MessageSetCorrectExtension2;
        pub use super::TestAllTypesProto2NestedEnum as NestedEnum;
        pub use super::TestAllTypesProto2NestedMessage as NestedMessage;
    }
    pub mod test_large_oneof {
        pub use super::A1;
        pub use super::A2;
        pub use super::A3;
        pub use super::A4;
        pub use super::A5;
    }
    pub mod unknown_to_test_all_types {
        pub use super::OptionalGroup;
    }
}
#[allow(unused_imports, reason = "generated by protoc-gen-pbrs")]
pub use __gen::*;