pbrs 0.2.0

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

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

    #[repr(transparent)]
    #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
    pub struct NullValue(i32);
    #[allow(non_upper_case_globals, reason = "protobuf enum names")]
    impl NullValue {
        pub const NullValue: NullValue = NullValue(0);
        fn constant_name(self) -> Option<&'static str> {
            #[allow(unreachable_patterns, reason = "open enums")]
            Some(match self.0 {
                0 => "NullValue",
                _ => return None,
            })
        }
    }
    impl From<NullValue> for i32 {
        fn from(v: NullValue) -> i32 {
            v.0
        }
    }
    impl From<i32> for NullValue {
        fn from(val: i32) -> Self {
            Self(val)
        }
    }
    impl Default for NullValue {
        fn default() -> Self {
            Self(0)
        }
    }
    impl std::fmt::Debug for NullValue {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            if let Some(n) = self.constant_name() {
                write!(f, "NullValue::{n}")
            } else {
                write!(f, "NullValue::from({})", self.0)
            }
        }
    }
    impl pbrs::__internal::SealedInternal for NullValue {}
    impl pbrs::Proxied for NullValue {
        type View<'msg> = NullValue;
    }
    impl pbrs::AsView for NullValue {
        type Proxied = Self;
        fn as_view(&self) -> Self {
            *self
        }
    }
    impl<'msg> pbrs::IntoView<'msg> for NullValue {
        fn into_view<'shorter>(self) -> Self
        where
            'msg: 'shorter,
        {
            self
        }
    }
    impl Enum for NullValue {
        const NAME: &'static str = "NullValue";
        fn is_known(value: i32) -> bool {
            matches!(value, 0)
        }
    }
    #[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 From<i32> for Bool {
        fn from(val: i32) -> Self {
            Self(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 ForeignEnum(i32);
    #[allow(non_upper_case_globals, reason = "protobuf enum names")]
    impl ForeignEnum {
        pub const ForeignFoo: ForeignEnum = ForeignEnum(0);
        pub const ForeignBar: ForeignEnum = ForeignEnum(1);
        pub const ForeignBaz: ForeignEnum = ForeignEnum(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<ForeignEnum> for i32 {
        fn from(v: ForeignEnum) -> i32 {
            v.0
        }
    }
    impl From<i32> for ForeignEnum {
        fn from(val: i32) -> Self {
            Self(val)
        }
    }
    impl Default for ForeignEnum {
        fn default() -> Self {
            Self(0)
        }
    }
    impl std::fmt::Debug for ForeignEnum {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            if let Some(n) = self.constant_name() {
                write!(f, "ForeignEnum::{n}")
            } else {
                write!(f, "ForeignEnum::from({})", self.0)
            }
        }
    }
    impl pbrs::__internal::SealedInternal for ForeignEnum {}
    impl pbrs::Proxied for ForeignEnum {
        type View<'msg> = ForeignEnum;
    }
    impl pbrs::AsView for ForeignEnum {
        type Proxied = Self;
        fn as_view(&self) -> Self {
            *self
        }
    }
    impl<'msg> pbrs::IntoView<'msg> for ForeignEnum {
        fn into_view<'shorter>(self) -> Self
        where
            'msg: 'shorter,
        {
            self
        }
    }
    impl Enum for ForeignEnum {
        const NAME: &'static str = "ForeignEnum";
        fn is_known(value: i32) -> bool {
            matches!(value, 0 | 1 | 2)
        }
    }
    #[repr(transparent)]
    #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
    pub struct AliasedEnum(i32);
    #[allow(non_upper_case_globals, reason = "protobuf enum names")]
    impl AliasedEnum {
        pub const AliasFoo: AliasedEnum = AliasedEnum(0);
        pub const AliasBar: AliasedEnum = AliasedEnum(1);
        pub const AliasBaz: AliasedEnum = AliasedEnum(2);
        pub const Moo: AliasedEnum = AliasedEnum(2);
        pub const Baz: AliasedEnum = AliasedEnum(2);
        fn constant_name(self) -> Option<&'static str> {
            #[allow(unreachable_patterns, reason = "open enums")]
            Some(match self.0 {
                0 => "AliasFoo",
                1 => "AliasBar",
                2 => "AliasBaz",
                _ => return None,
            })
        }
    }
    impl From<AliasedEnum> for i32 {
        fn from(v: AliasedEnum) -> i32 {
            v.0
        }
    }
    impl From<i32> for AliasedEnum {
        fn from(val: i32) -> Self {
            Self(val)
        }
    }
    impl Default for AliasedEnum {
        fn default() -> Self {
            Self(0)
        }
    }
    impl std::fmt::Debug for AliasedEnum {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            if let Some(n) = self.constant_name() {
                write!(f, "AliasedEnum::{n}")
            } else {
                write!(f, "AliasedEnum::from({})", self.0)
            }
        }
    }
    impl pbrs::__internal::SealedInternal for AliasedEnum {}
    impl pbrs::Proxied for AliasedEnum {
        type View<'msg> = AliasedEnum;
    }
    impl pbrs::AsView for AliasedEnum {
        type Proxied = Self;
        fn as_view(&self) -> Self {
            *self
        }
    }
    impl<'msg> pbrs::IntoView<'msg> for AliasedEnum {
        fn into_view<'shorter>(self) -> Self
        where
            'msg: 'shorter,
        {
            self
        }
    }
    impl Enum for AliasedEnum {
        const NAME: &'static str = "AliasedEnum";
        fn is_known(value: i32) -> bool {
            matches!(value, 0 | 1 | 2)
        }
    }
    #[repr(transparent)]
    #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
    pub struct NestedEnum(i32);
    #[allow(non_upper_case_globals, reason = "protobuf enum names")]
    impl NestedEnum {
        pub const Foo: NestedEnum = NestedEnum(0);
        pub const Bar: NestedEnum = NestedEnum(1);
        pub const Baz: NestedEnum = NestedEnum(2);
        pub const Neg: NestedEnum = NestedEnum(-1);
        fn constant_name(self) -> Option<&'static str> {
            #[allow(unreachable_patterns, reason = "open enums")]
            Some(match self.0 {
                0 => "Foo",
                1 => "Bar",
                2 => "Baz",
                -1 => "Neg",
                _ => return None,
            })
        }
    }
    impl From<NestedEnum> for i32 {
        fn from(v: NestedEnum) -> i32 {
            v.0
        }
    }
    impl From<i32> for NestedEnum {
        fn from(val: i32) -> Self {
            Self(val)
        }
    }
    impl Default for NestedEnum {
        fn default() -> Self {
            Self(0)
        }
    }
    impl std::fmt::Debug for NestedEnum {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            if let Some(n) = self.constant_name() {
                write!(f, "NestedEnum::{n}")
            } else {
                write!(f, "NestedEnum::from({})", self.0)
            }
        }
    }
    impl pbrs::__internal::SealedInternal for NestedEnum {}
    impl pbrs::Proxied for NestedEnum {
        type View<'msg> = NestedEnum;
    }
    impl pbrs::AsView for NestedEnum {
        type Proxied = Self;
        fn as_view(&self) -> Self {
            *self
        }
    }
    impl<'msg> pbrs::IntoView<'msg> for NestedEnum {
        fn into_view<'shorter>(self) -> Self
        where
            'msg: 'shorter,
        {
            self
        }
    }
    impl Enum for NestedEnum {
        const NAME: &'static str = "NestedEnum";
        fn is_known(value: i32) -> bool {
            matches!(value, 0 | 1 | 2 | -1)
        }
    }
    #[derive(Clone, Debug)]
    pub struct Any {
        type_url: pbrs::rt::LazyStr,
        value: pbrs::rt::LazyBytes,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for Any {
        fn eq(&self, other: &Self) -> bool {
            if self.type_url != other.type_url {
                return false;
            }
            if self.value != other.value {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for Any {}
    impl Default for Any {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl Any {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.Any";
        pub fn type_url(&self) -> &pbrs::ProtoStr {
            self.type_url.as_view()
        }
        pub fn set_type_url(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.type_url = pbrs::rt::LazyStr::owned(v.into_proxied(pbrs::__internal::Private));
        }
        pub fn value(&self) -> &[u8] {
            self.value.as_bytes()
        }
        pub fn set_value(&mut self, v: impl pbrs::IntoProxied<ProtoBytes>) {
            self.cached_size.dirty();
            self.value = pbrs::rt::LazyBytes::owned(v.into_proxied(pbrs::__internal::Private));
        }
        #[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];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.type_url = 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)?),
                    },
                    2 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.value = pbrs::rt::LazyBytes::from_parse_span(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)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    2 => match w {
                        pbrs::rt::WIRE_LEN => {
                            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 !self.type_url.is_empty() {
                n += pbrs::rt::key_len_value_len(1, self.type_url.as_bytes().len() as u64);
            }
            if !self.value.is_empty() {
                n += pbrs::rt::key_len_value_len(2, self.value.as_bytes().len() as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if !self.type_url.is_empty() {
                pbrs::rt::encode_len_field(out, 1, self.type_url.as_bytes());
            }
            if !self.value.is_empty() {
                pbrs::rt::encode_len_field(out, 2, self.value.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("google.protobuf.Any")
                .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("google.protobuf.Any")
                .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("google.protobuf.Any")
                .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("google.protobuf.Any")
                .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("google.protobuf.Any")
                .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!(Any, AnyView, AnyMut);
    #[derive(Clone, Debug)]
    pub struct BoolValue {
        value: bool,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for BoolValue {
        fn eq(&self, other: &Self) -> bool {
            if self.value != other.value {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for BoolValue {}
    impl Default for BoolValue {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl BoolValue {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.BoolValue";
        pub fn value(&self) -> bool {
            self.value
        }
        pub fn set_value(&mut self, v: bool) {
            self.cached_size.dirty();
            self.value = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.value = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => 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)? != 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"));
            }
            Ok(())
        }
        fn compute_size(&self) -> u64 {
            if let Some(n) = self.cached_size.get() {
                return n;
            }
            let mut n = self.unknown.encoded_len();
            if self.value {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(u64::from(self.value));
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if self.value {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, u64::from(self.value));
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            Ok(pbrs::json::boolean(self.value()))
        }
        fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            msg.set_value(pbrs::json::as_bool(v)?);
            Ok(msg)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            if self.value() {
                pbrs::text::write_named_bool(out, indent, "value", self.value());
            }
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    "value" => {
                        msg.set_value(val.as_bool()?);
                    }
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(BoolValue, BoolValueView, BoolValueMut);
    #[derive(Clone, Debug)]
    pub struct BytesValue {
        value: pbrs::rt::LazyBytes,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for BytesValue {
        fn eq(&self, other: &Self) -> bool {
            if self.value != other.value {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for BytesValue {}
    impl Default for BytesValue {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl BytesValue {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.BytesValue";
        pub fn value(&self) -> &[u8] {
            self.value.as_bytes()
        }
        pub fn set_value(&mut self, v: impl pbrs::IntoProxied<ProtoBytes>) {
            self.cached_size.dirty();
            self.value = pbrs::rt::LazyBytes::owned(v.into_proxied(pbrs::__internal::Private));
        }
        #[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)?;
                            self.value = pbrs::rt::LazyBytes::from_parse_span(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 => {
                            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 !self.value.is_empty() {
                n += pbrs::rt::key_len_value_len(1, self.value.as_bytes().len() as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if !self.value.is_empty() {
                pbrs::rt::encode_len_field(out, 1, self.value.as_bytes());
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            Ok(pbrs::json::bytes(self.value()))
        }
        fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            msg.set_value(pbrs::json::as_bytes(v)?);
            Ok(msg)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            if !self.value().is_empty() {
                pbrs::text::write_named_string(out, indent, "value", self.value());
            }
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    "value" => {
                        msg.set_value(val.as_bytes()?);
                    }
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(BytesValue, BytesValueView, BytesValueMut);
    #[derive(Clone, Debug)]
    pub struct DoubleValue {
        value: f64,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for DoubleValue {
        fn eq(&self, other: &Self) -> bool {
            if self.value != other.value {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for DoubleValue {}
    impl Default for DoubleValue {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl DoubleValue {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.DoubleValue";
        pub fn value(&self) -> f64 {
            self.value
        }
        pub fn set_value(&mut self, v: f64) {
            self.cached_size.dirty();
            self.value = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_I64 => {
                            self.value = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => 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_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(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 self.value.to_bits() != 0 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_I64) + 8;
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if self.value.to_bits() != 0 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(self.value).to_bits().to_le_bytes());
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            Ok(pbrs::json::double(self.value()))
        }
        fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            msg.set_value(pbrs::json::as_f64(v)?);
            Ok(msg)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            if self.value().to_bits() != 0 {
                pbrs::text::write_named_double(out, indent, "value", self.value());
            }
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    "value" => {
                        msg.set_value(val.as_f64()?);
                    }
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(DoubleValue, DoubleValueView, DoubleValueMut);
    #[derive(Clone, Debug)]
    pub struct Duration {
        seconds: i64,
        nanos: i32,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for Duration {
        fn eq(&self, other: &Self) -> bool {
            if self.seconds != other.seconds {
                return false;
            }
            if self.nanos != other.nanos {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for Duration {}
    impl Default for Duration {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl Duration {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.Duration";
        pub fn seconds(&self) -> i64 {
            self.seconds
        }
        pub fn set_seconds(&mut self, v: i64) {
            self.cached_size.dirty();
            self.seconds = v;
        }
        pub fn nanos(&self) -> i32 {
            self.nanos
        }
        pub fn set_nanos(&mut self, v: i32) {
            self.cached_size.dirty();
            self.nanos = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.seconds = pbrs::rt::decode_varint(data, pos)? as i64;
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    2 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.nanos = 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 i64;
                        }
                        _ => 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 self.seconds != 0 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.seconds) as u64);
            }
            if self.nanos != 0 {
                n += pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.nanos) as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if self.seconds != 0 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.seconds as u64);
            }
            if self.nanos != 0 {
                pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.nanos as u64);
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            pbrs::json::duration(self.seconds(), self.nanos())
        }
        fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
            let (seconds, nanos) = pbrs::json::as_duration(v)?;
            let mut msg = Self::new();
            msg.set_seconds(seconds);
            msg.set_nanos(nanos);
            Ok(msg)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            if self.seconds() != 0 {
                pbrs::text::write_named_int64(out, indent, "seconds", self.seconds());
            }
            if self.nanos() != 0 {
                pbrs::text::write_named_int32(out, indent, "nanos", self.nanos());
            }
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    "seconds" => {
                        msg.set_seconds(val.as_i64()?);
                    }
                    "nanos" => {
                        msg.set_nanos(val.as_i32()?);
                    }
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(Duration, DurationView, DurationMut);
    #[derive(Clone, Debug)]
    pub struct Empty {
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for Empty {
        fn eq(&self, other: &Self) -> bool {
            self.unknown == other.unknown
        }
    }
    impl Eq for Empty {}
    impl Default for Empty {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl Empty {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.Empty";
        #[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> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            Ok(pbrs::json::empty())
        }
        fn from_json_value(v: &pbrs::json::Json, ignore: bool) -> Result<Self, ParseError> {
            pbrs::json::as_empty(v, ignore)?;
            Ok(Self::new())
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(Empty, EmptyView, EmptyMut);
    #[derive(Clone, Debug)]
    pub struct FieldMask {
        paths: Repeated<pbrs::rt::LazyStr>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for FieldMask {
        fn eq(&self, other: &Self) -> bool {
            if self.paths != other.paths {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for FieldMask {}
    impl Default for FieldMask {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl FieldMask {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.FieldMask";
        pub fn paths(&self) -> RepeatedView<'_, pbrs::rt::LazyStr> {
            self.paths.as_view()
        }
        pub fn paths_mut(&mut self) -> RepeatedMut<'_, pbrs::rt::LazyStr> {
            self.cached_size.dirty();
            self.paths.as_mut()
        }
        pub fn set_paths(&mut self, v: impl IntoIterator<Item = pbrs::rt::LazyStr>) {
            self.cached_size.dirty();
            self.paths = 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_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.paths.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_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    _ => 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();
            for t in self.paths.iter() {
                n += pbrs::rt::key_len_value_len(1, t.as_bytes().len() as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            for t in self.paths.iter() {
                pbrs::rt::encode_len_field(out, 1, 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("google.protobuf.FieldMask")
                .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("google.protobuf.FieldMask")
                .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("google.protobuf.FieldMask")
                .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("google.protobuf.FieldMask")
                .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("google.protobuf.FieldMask")
                .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!(FieldMask, FieldMaskView, FieldMaskMut);
    #[derive(Clone, Debug)]
    pub struct FloatValue {
        value: f32,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for FloatValue {
        fn eq(&self, other: &Self) -> bool {
            if self.value != other.value {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for FloatValue {}
    impl Default for FloatValue {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl FloatValue {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.FloatValue";
        pub fn value(&self) -> f32 {
            self.value
        }
        pub fn set_value(&mut self, v: f32) {
            self.cached_size.dirty();
            self.value = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_I32 => {
                            self.value = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => 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_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(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 self.value.to_bits() != 0 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32) + 4;
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if self.value.to_bits() != 0 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(self.value).to_bits().to_le_bytes());
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            Ok(pbrs::json::float(self.value()))
        }
        fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            msg.set_value(pbrs::json::as_f32(v)?);
            Ok(msg)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            if self.value().to_bits() != 0 {
                pbrs::text::write_named_float(out, indent, "value", self.value());
            }
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    "value" => {
                        msg.set_value(val.as_f32()?);
                    }
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(FloatValue, FloatValueView, FloatValueMut);
    #[derive(Clone, Debug)]
    pub struct Int32Value {
        value: i32,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for Int32Value {
        fn eq(&self, other: &Self) -> bool {
            if self.value != other.value {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for Int32Value {}
    impl Default for Int32Value {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl Int32Value {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.Int32Value";
        pub fn value(&self) -> i32 {
            self.value
        }
        pub fn set_value(&mut self, v: i32) {
            self.cached_size.dirty();
            self.value = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.value = 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 self.value != 0 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.value) as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if self.value != 0 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.value as u64);
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            Ok(pbrs::json::int32(self.value()))
        }
        fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            msg.set_value(pbrs::json::as_i32(v)?);
            Ok(msg)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            if self.value() != 0 {
                pbrs::text::write_named_int32(out, indent, "value", self.value());
            }
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    "value" => {
                        msg.set_value(val.as_i32()?);
                    }
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(Int32Value, Int32ValueView, Int32ValueMut);
    #[derive(Clone, Debug)]
    pub struct Int64Value {
        value: i64,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for Int64Value {
        fn eq(&self, other: &Self) -> bool {
            if self.value != other.value {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for Int64Value {}
    impl Default for Int64Value {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl Int64Value {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.Int64Value";
        pub fn value(&self) -> i64 {
            self.value
        }
        pub fn set_value(&mut self, v: i64) {
            self.cached_size.dirty();
            self.value = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.value = pbrs::rt::decode_varint(data, pos)? as i64;
                        }
                        _ => 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 i64;
                        }
                        _ => 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 self.value != 0 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.value) as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if self.value != 0 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.value as u64);
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            Ok(pbrs::json::int64(self.value()))
        }
        fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            msg.set_value(pbrs::json::as_i64(v)?);
            Ok(msg)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            if self.value() != 0 {
                pbrs::text::write_named_int64(out, indent, "value", self.value());
            }
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    "value" => {
                        msg.set_value(val.as_i64()?);
                    }
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(Int64Value, Int64ValueView, Int64ValueMut);
    #[derive(Clone, Debug)]
    pub struct ListValue {
        values: Repeated<PbValue>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for ListValue {
        fn eq(&self, other: &Self) -> bool {
            if self.values != other.values {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for ListValue {}
    impl Default for ListValue {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl ListValue {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.ListValue";
        pub fn values(&self) -> RepeatedView<'_, PbValue> {
            self.values.as_view()
        }
        pub fn values_mut(&mut self) -> RepeatedMut<'_, PbValue> {
            self.cached_size.dirty();
            self.values.as_mut()
        }
        pub fn set_values(&mut self, v: impl IntoIterator<Item = PbValue>) {
            self.cached_size.dirty();
            self.values = 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_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let rest = data.len().saturating_sub(e);
                            if rest > 2 {
                                self.values.reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = PbValue::default();
                            let mut ip = 0;
                            let mut sw = None;
                            inner.merge_inner(
                                &data[s..e],
                                &mut sw,
                                &mut ip,
                                depth + 1,
                                true,
                                None,
                            )?;
                            self.values.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 1 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = PbValue::default();
                                        let mut ip = 0;
                                        let mut sw = None;
                                        inner.merge_inner(
                                            &data[s..e],
                                            &mut sw,
                                            &mut ip,
                                            depth + 1,
                                            true,
                                            None,
                                        )?;
                                        self.values.push(inner);
                                    }
                                    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 {
                    1 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            PbValue::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();
            for t in self.values.iter() {
                n += pbrs::rt::key_len_value_len(1, t.compute_size());
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            for t in self.values.iter() {
                pbrs::rt::encode_len_header(out, 1, t.compute_size());
                t.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("google.protobuf.ListValue")
                .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("google.protobuf.ListValue")
                .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("google.protobuf.ListValue")
                .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("google.protobuf.ListValue")
                .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("google.protobuf.ListValue")
                .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!(ListValue, ListValueView, ListValueMut);
    #[derive(Clone, Debug)]
    pub struct StringValue {
        value: pbrs::rt::LazyStr,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for StringValue {
        fn eq(&self, other: &Self) -> bool {
            if self.value != other.value {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for StringValue {}
    impl Default for StringValue {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl StringValue {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.StringValue";
        pub fn value(&self) -> &pbrs::ProtoStr {
            self.value.as_view()
        }
        pub fn set_value(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.value = pbrs::rt::LazyStr::owned(v.into_proxied(pbrs::__internal::Private));
        }
        #[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];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.value = 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)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => 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 !self.value.is_empty() {
                n += pbrs::rt::key_len_value_len(1, self.value.as_bytes().len() as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if !self.value.is_empty() {
                pbrs::rt::encode_len_field(out, 1, self.value.as_bytes());
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            Ok(pbrs::json::string(self.value().as_bytes()))
        }
        fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            msg.set_value(pbrs::json::as_str(v)?);
            Ok(msg)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            if !self.value().as_bytes().is_empty() {
                pbrs::text::write_named_string(out, indent, "value", self.value().as_bytes());
            }
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    "value" => {
                        msg.set_value(val.as_str()?);
                    }
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(StringValue, StringValueView, StringValueMut);
    #[derive(Clone, Debug)]
    pub struct Struct {
        fields: Map<pbrs::rt::LazyStr, PbValue>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for Struct {
        fn eq(&self, other: &Self) -> bool {
            if self.fields != other.fields {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for Struct {}
    impl Default for Struct {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl Struct {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.Struct";
        pub fn fields(&self) -> MapView<'_, pbrs::rt::LazyStr, PbValue> {
            self.fields.as_view()
        }
        pub fn fields_mut(&mut self) -> MapMut<'_, pbrs::rt::LazyStr, PbValue> {
            self.cached_size.dirty();
            self.fields.as_mut()
        }
        pub fn set_fields(&mut self, v: Map<pbrs::rt::LazyStr, PbValue>) {
            self.cached_size.dirty();
            self.fields = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) = decode_map_entry_Struct_fields_1(
                                &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                depth + 1,
                            )?;
                            self.fields.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    _ => self
                        .unknown
                        .fields
                        .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            if enforce {
                self.check_required()?;
            }
            Ok(())
        }
        fn validate_inner(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
        ) -> Result<(), ParseError> {
            Self::validate_until(wire, pos, depth, None)
        }
        fn validate_until(
            wire: &pbrs::rt::Wire,
            pos: &mut usize,
            depth: u32,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let data = wire.as_slice();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    _ => pbrs::rt::skip_field(data, pos, w)?,
                }
            }
            if until.is_some() {
                return Err(ParseError::new("truncated group"));
            }
            Ok(())
        }
        fn compute_size(&self) -> u64 {
            if let Some(n) = self.cached_size.get() {
                return n;
            }
            let mut n = self.unknown.encoded_len();
            if !self.fields.is_empty() {
                for (k, v) in self.fields.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(1, inner);
                }
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if !self.fields.is_empty() {
                for (k, v) in self.fields.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, 1, 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);
                }
            }
            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("google.protobuf.Struct")
                .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("google.protobuf.Struct")
                .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("google.protobuf.Struct")
                .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("google.protobuf.Struct")
                .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("google.protobuf.Struct")
                .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!(Struct, StructView, StructMut);
    fn decode_map_entry_Struct_fields_1(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, PbValue), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = PbValue::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    let mut ip = 0;
                    let mut sw = None;
                    val.merge_inner(&data[s..e], &mut sw, &mut ip, depth, true, None)?;
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    #[derive(Clone, Debug)]
    pub struct Timestamp {
        seconds: i64,
        nanos: i32,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for Timestamp {
        fn eq(&self, other: &Self) -> bool {
            if self.seconds != other.seconds {
                return false;
            }
            if self.nanos != other.nanos {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for Timestamp {}
    impl Default for Timestamp {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl Timestamp {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.Timestamp";
        pub fn seconds(&self) -> i64 {
            self.seconds
        }
        pub fn set_seconds(&mut self, v: i64) {
            self.cached_size.dirty();
            self.seconds = v;
        }
        pub fn nanos(&self) -> i32 {
            self.nanos
        }
        pub fn set_nanos(&mut self, v: i32) {
            self.cached_size.dirty();
            self.nanos = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.seconds = pbrs::rt::decode_varint(data, pos)? as i64;
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    2 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.nanos = 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 i64;
                        }
                        _ => 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 self.seconds != 0 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.seconds) as u64);
            }
            if self.nanos != 0 {
                n += pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.nanos) as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if self.seconds != 0 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.seconds as u64);
            }
            if self.nanos != 0 {
                pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.nanos as u64);
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            pbrs::json::timestamp(self.seconds(), self.nanos())
        }
        fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
            let (seconds, nanos) = pbrs::json::as_timestamp(v)?;
            let mut msg = Self::new();
            msg.set_seconds(seconds);
            msg.set_nanos(nanos);
            Ok(msg)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            if self.seconds() != 0 {
                pbrs::text::write_named_int64(out, indent, "seconds", self.seconds());
            }
            if self.nanos() != 0 {
                pbrs::text::write_named_int32(out, indent, "nanos", self.nanos());
            }
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    "seconds" => {
                        msg.set_seconds(val.as_i64()?);
                    }
                    "nanos" => {
                        msg.set_nanos(val.as_i32()?);
                    }
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(Timestamp, TimestampView, TimestampMut);
    #[derive(Clone, Debug)]
    pub struct UInt32Value {
        value: u32,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for UInt32Value {
        fn eq(&self, other: &Self) -> bool {
            if self.value != other.value {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for UInt32Value {}
    impl Default for UInt32Value {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl UInt32Value {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.UInt32Value";
        pub fn value(&self) -> u32 {
            self.value
        }
        pub fn set_value(&mut self, v: u32) {
            self.cached_size.dirty();
            self.value = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.value = 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 {
                    1 => 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 self.value != 0 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.value) as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if self.value != 0 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.value as u64);
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            Ok(pbrs::json::uint32(self.value()))
        }
        fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            msg.set_value(pbrs::json::as_u32(v)?);
            Ok(msg)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            if self.value() != 0 {
                pbrs::text::write_named_uint32(out, indent, "value", self.value());
            }
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    "value" => {
                        msg.set_value(val.as_u32()?);
                    }
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(UInt32Value, UInt32ValueView, UInt32ValueMut);
    #[derive(Clone, Debug)]
    pub struct UInt64Value {
        value: u64,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for UInt64Value {
        fn eq(&self, other: &Self) -> bool {
            if self.value != other.value {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for UInt64Value {}
    impl Default for UInt64Value {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl UInt64Value {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.UInt64Value";
        pub fn value(&self) -> u64 {
            self.value
        }
        pub fn set_value(&mut self, v: u64) {
            self.cached_size.dirty();
            self.value = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.value = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => 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)?;
                        }
                        _ => 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 self.value != 0 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.value) as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if self.value != 0 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.value as u64);
            }
            self.unknown.encode(out);
        }
        pub fn to_json(&self) -> Result<String, SerializeError> {
            Ok(self.to_json_value()?.to_string())
        }
        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 v = pbrs::json::parse(json)?;
            Self::from_json_value(&v, ignore)
        }
        fn to_json_value(&self) -> Result<pbrs::json::Json, SerializeError> {
            Ok(pbrs::json::uint64(self.value()))
        }
        fn from_json_value(v: &pbrs::json::Json, _ignore: bool) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            msg.set_value(pbrs::json::as_u64(v)?);
            Ok(msg)
        }
        pub fn to_text(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            Ok(out)
        }
        pub fn to_text_with_unknown(&self) -> Result<String, SerializeError> {
            let mut out = String::new();
            self.write_text(&mut out, 0)?;
            pbrs::text::write_unknown_fields(&self.unknown, &mut out, 0);
            Ok(out)
        }
        pub fn from_text(text: &str) -> Result<Self, ParseError> {
            Self::from_text_value(&pbrs::text::parse(text)?)
        }
        fn write_text(&self, out: &mut String, indent: usize) -> Result<(), SerializeError> {
            if self.value() != 0 {
                pbrs::text::write_named_uint64(out, indent, "value", self.value());
            }
            Ok(())
        }
        fn from_text_value(fields: &[(String, pbrs::text::TextValue)]) -> Result<Self, ParseError> {
            let mut msg = Self::new();
            for (key, val) in fields {
                match key.as_str() {
                    "value" => {
                        msg.set_value(val.as_u64()?);
                    }
                    _ => return Err(ParseError::owned(format!("unknown field {key}"))),
                }
            }
            Ok(msg)
        }
    }
    pbrs::impl_typed_message!(UInt64Value, UInt64ValueView, UInt64ValueMut);
    #[derive(Clone, Debug)]
    pub struct PbValue {
        null_value: Option<i32>,
        number_value: Option<f64>,
        string_value: Option<Box<pbrs::rt::LazyStr>>,
        bool_value: pbrs::rt::OptBool,
        struct_value: pbrs::rt::LazyMsg<Struct>,
        list_value: pbrs::rt::LazyMsg<ListValue>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for PbValue {
        fn eq(&self, other: &Self) -> bool {
            if self.null_value != other.null_value {
                return false;
            }
            if self.number_value != other.number_value {
                return false;
            }
            if self.string_value != other.string_value {
                return false;
            }
            if self.bool_value != other.bool_value {
                return false;
            }
            if self.struct_value != other.struct_value {
                return false;
            }
            if self.list_value != other.list_value {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for PbValue {}
    impl Default for PbValue {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl PbValue {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "google.protobuf.Value";
        pub fn has_null_value(&self) -> bool {
            self.null_value.is_some()
        }
        pub fn null_value(&self) -> NullValue {
            NullValue(self.null_value.unwrap_or(0))
        }
        pub fn null_value_opt(&self) -> Option<NullValue> {
            self.null_value.map(|v| NullValue(v))
        }
        pub fn set_null_value(&mut self, v: impl Into<i32>) {
            self.cached_size.dirty();
            self.number_value = None;
            self.string_value = None;
            self.bool_value = pbrs::rt::OptBool::NONE;
            self.struct_value = Default::default();
            self.list_value = Default::default();
            self.null_value = Some(v.into());
        }
        pub fn clear_null_value(&mut self) {
            self.cached_size.dirty();
            self.null_value = None;
        }
        pub fn has_number_value(&self) -> bool {
            self.number_value.is_some()
        }
        pub fn number_value(&self) -> f64 {
            self.number_value.unwrap_or(0.0)
        }
        pub fn number_value_opt(&self) -> Option<f64> {
            self.number_value.map(|v| v)
        }
        pub fn set_number_value(&mut self, v: f64) {
            self.cached_size.dirty();
            self.null_value = None;
            self.string_value = None;
            self.bool_value = pbrs::rt::OptBool::NONE;
            self.struct_value = Default::default();
            self.list_value = Default::default();
            self.number_value = Some(v);
        }
        pub fn clear_number_value(&mut self) {
            self.cached_size.dirty();
            self.number_value = None;
        }
        pub fn has_string_value(&self) -> bool {
            self.string_value.is_some()
        }
        pub fn string_value(&self) -> &pbrs::ProtoStr {
            self.string_value
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn string_value_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.string_value.as_ref().map(|s| s.as_view())
        }
        pub fn set_string_value(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.null_value = None;
            self.number_value = None;
            self.bool_value = pbrs::rt::OptBool::NONE;
            self.struct_value = Default::default();
            self.list_value = Default::default();
            self.string_value = Some(Box::new(pbrs::rt::LazyStr::owned(
                v.into_proxied(pbrs::__internal::Private),
            )));
        }
        pub fn clear_string_value(&mut self) {
            self.cached_size.dirty();
            self.string_value = None;
        }
        pub fn has_bool_value(&self) -> bool {
            self.bool_value.is_some()
        }
        pub fn bool_value(&self) -> bool {
            self.bool_value.unwrap_or(false)
        }
        pub fn bool_value_opt(&self) -> Option<bool> {
            self.bool_value.get()
        }
        pub fn set_bool_value(&mut self, v: bool) {
            self.cached_size.dirty();
            self.null_value = None;
            self.number_value = None;
            self.string_value = None;
            self.struct_value = Default::default();
            self.list_value = Default::default();
            self.bool_value = pbrs::rt::OptBool::some(v);
        }
        pub fn clear_bool_value(&mut self) {
            self.cached_size.dirty();
            self.bool_value = pbrs::rt::OptBool::NONE;
        }
        pub fn has_struct_value(&self) -> bool {
            self.struct_value.is_some()
        }
        pub fn struct_value(&self) -> &Struct {
            self.struct_value
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn struct_value_opt(&self) -> Option<&Struct> {
            self.struct_value.as_deref()
        }
        pub fn struct_value_view(&self) -> StructView<'_> {
            StructView(self.struct_value())
        }
        pub fn set_struct_value(&mut self, v: Struct) {
            self.cached_size.dirty();
            self.null_value = None;
            self.number_value = None;
            self.string_value = None;
            self.bool_value = pbrs::rt::OptBool::NONE;
            self.list_value = Default::default();
            self.struct_value = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn struct_value_mut(&mut self) -> &mut Struct {
            self.cached_size.dirty();
            self.struct_value.get_or_insert()
        }
        pub fn clear_struct_value(&mut self) {
            self.cached_size.dirty();
            self.struct_value.clear();
        }
        pub fn has_list_value(&self) -> bool {
            self.list_value.is_some()
        }
        pub fn list_value(&self) -> &ListValue {
            self.list_value
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn list_value_opt(&self) -> Option<&ListValue> {
            self.list_value.as_deref()
        }
        pub fn list_value_view(&self) -> ListValueView<'_> {
            ListValueView(self.list_value())
        }
        pub fn set_list_value(&mut self, v: ListValue) {
            self.cached_size.dirty();
            self.null_value = None;
            self.number_value = None;
            self.string_value = None;
            self.bool_value = pbrs::rt::OptBool::NONE;
            self.struct_value = Default::default();
            self.list_value = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn list_value_mut(&mut self) -> &mut ListValue {
            self.cached_size.dirty();
            self.list_value.get_or_insert()
        }
        pub fn clear_list_value(&mut self) {
            self.cached_size.dirty();
            self.list_value.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.number_value = None;
                            self.string_value = None;
                            self.bool_value = pbrs::rt::OptBool::NONE;
                            self.struct_value = Default::default();
                            self.list_value = Default::default();
                            self.null_value = 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_I64 => {
                            self.null_value = None;
                            self.string_value = None;
                            self.bool_value = pbrs::rt::OptBool::NONE;
                            self.struct_value = Default::default();
                            self.list_value = Default::default();
                            self.number_value =
                                Some(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    3 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.null_value = None;
                            self.number_value = None;
                            self.bool_value = pbrs::rt::OptBool::NONE;
                            self.struct_value = Default::default();
                            self.list_value = Default::default();
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.string_value = 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)?),
                    },
                    4 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.null_value = None;
                            self.number_value = None;
                            self.string_value = None;
                            self.struct_value = Default::default();
                            self.list_value = Default::default();
                            self.bool_value =
                                pbrs::rt::OptBool::some(pbrs::rt::decode_varint(data, pos)? != 0);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    5 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.null_value = None;
                            self.number_value = None;
                            self.string_value = None;
                            self.bool_value = pbrs::rt::OptBool::NONE;
                            self.list_value = Default::default();
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.struct_value.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.struct_value.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                Struct::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.struct_value = 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)?),
                    },
                    6 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.null_value = None;
                            self.number_value = None;
                            self.string_value = None;
                            self.bool_value = pbrs::rt::OptBool::NONE;
                            self.struct_value = Default::default();
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.list_value.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.list_value.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                ListValue::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.list_value = 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_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(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)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    4 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => 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;
                            Struct::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    6 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            ListValue::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.null_value {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT) + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.number_value {
                n += pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(s) = &self.string_value {
                n += pbrs::rt::key_len_value_len(3, s.as_bytes().len() as u64);
            }
            if let Some(v) = self.bool_value.get() {
                n += pbrs::rt::tag_len(4, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(u64::from(v));
            }
            if let Some(p) = self.struct_value.wire_bytes() {
                n += pbrs::rt::key_len_value_len(5, p.len() as u64);
            } else if let Some(m) = self.struct_value.as_deref() {
                n += pbrs::rt::key_len_value_len(5, m.compute_size());
            }
            if let Some(p) = self.list_value.wire_bytes() {
                n += pbrs::rt::key_len_value_len(6, p.len() as u64);
            } else if let Some(m) = self.list_value.as_deref() {
                n += pbrs::rt::key_len_value_len(6, m.compute_size());
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if let Some(v) = self.null_value {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.number_value {
                pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(v).to_bits().to_le_bytes());
            }
            if let Some(s) = &self.string_value {
                pbrs::rt::encode_len_field(out, 3, s.as_bytes());
            }
            if let Some(v) = self.bool_value.get() {
                pbrs::rt::encode_tag(out, 4, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, u64::from(v));
            }
            if let Some(p) = self.struct_value.wire_bytes() {
                pbrs::rt::encode_len_header(out, 5, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.struct_value.as_deref() {
                pbrs::rt::encode_len_header(out, 5, m.compute_size());
                m.write_to(out);
            }
            if let Some(p) = self.list_value.wire_bytes() {
                pbrs::rt::encode_len_header(out, 6, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.list_value.as_deref() {
                pbrs::rt::encode_len_header(out, 6, 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("google.protobuf.Value")
                .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("google.protobuf.Value")
                .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("google.protobuf.Value")
                .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("google.protobuf.Value")
                .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("google.protobuf.Value")
                .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!(PbValue, PbValueView, PbValueMut);
    #[derive(Clone, Debug)]
    pub struct EnumOnlyProto3 {
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for EnumOnlyProto3 {
        fn eq(&self, other: &Self) -> bool {
            self.unknown == other.unknown
        }
    }
    impl Eq for EnumOnlyProto3 {}
    impl Default for EnumOnlyProto3 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl EnumOnlyProto3 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto3.EnumOnlyProto3";
        #[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.proto3.EnumOnlyProto3")
                .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.proto3.EnumOnlyProto3")
                .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.proto3.EnumOnlyProto3")
                .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.proto3.EnumOnlyProto3")
                .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.proto3.EnumOnlyProto3")
                .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!(EnumOnlyProto3, EnumOnlyProto3View, EnumOnlyProto3Mut);
    #[derive(Clone, Debug)]
    pub struct ForeignMessage {
        c: i32,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for ForeignMessage {
        fn eq(&self, other: &Self) -> bool {
            if self.c != other.c {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for ForeignMessage {}
    impl Default for ForeignMessage {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl ForeignMessage {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto3.ForeignMessage";
        pub fn c(&self) -> i32 {
            self.c
        }
        pub fn set_c(&mut self, v: i32) {
            self.cached_size.dirty();
            self.c = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.c = 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 self.c != 0 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.c) as u64);
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if self.c != 0 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.c 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.proto3.ForeignMessage")
                .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.proto3.ForeignMessage")
                .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.proto3.ForeignMessage")
                .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.proto3.ForeignMessage")
                .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.proto3.ForeignMessage")
                .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!(ForeignMessage, ForeignMessageView, ForeignMessageMut);
    #[derive(Clone, Debug)]
    pub struct NullHypothesisProto3 {
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for NullHypothesisProto3 {
        fn eq(&self, other: &Self) -> bool {
            self.unknown == other.unknown
        }
    }
    impl Eq for NullHypothesisProto3 {}
    impl Default for NullHypothesisProto3 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl NullHypothesisProto3 {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto3.NullHypothesisProto3";
        #[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.proto3.NullHypothesisProto3")
                .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.proto3.NullHypothesisProto3")
                .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.proto3.NullHypothesisProto3")
                .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.proto3.NullHypothesisProto3")
                .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.proto3.NullHypothesisProto3")
                .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!(
        NullHypothesisProto3,
        NullHypothesisProto3View,
        NullHypothesisProto3Mut
    );
    #[derive(Clone, Debug, PartialEq)]
    struct TestAllTypesProto3Cold {
        repeated_int32: pbrs::rt::PackedI32,
        repeated_int64: pbrs::rt::PackedI64,
        repeated_uint32: pbrs::rt::PackedU32,
        repeated_uint64: pbrs::rt::PackedU64,
        repeated_sint32: pbrs::rt::PackedS32,
        repeated_sint64: pbrs::rt::PackedS64,
        repeated_fixed32: pbrs::rt::PackedFx32,
        repeated_fixed64: pbrs::rt::PackedFx64,
        repeated_sfixed32: pbrs::rt::PackedSfx32,
        repeated_sfixed64: pbrs::rt::PackedSfx64,
        repeated_float: pbrs::rt::PackedF32,
        repeated_double: pbrs::rt::PackedF64,
        repeated_bool: pbrs::rt::PackedBool,
        repeated_foreign_message: Repeated<ForeignMessage>,
        repeated_nested_enum: pbrs::rt::PackedI32,
        repeated_foreign_enum: pbrs::rt::PackedI32,
        packed_int32: pbrs::rt::PackedI32,
        packed_int64: pbrs::rt::PackedI64,
        packed_uint32: pbrs::rt::PackedU32,
        packed_uint64: pbrs::rt::PackedU64,
        packed_sint32: pbrs::rt::PackedS32,
        packed_sint64: pbrs::rt::PackedS64,
        packed_sfixed32: pbrs::rt::PackedSfx32,
        packed_sfixed64: pbrs::rt::PackedSfx64,
        packed_double: pbrs::rt::PackedF64,
        packed_bool: pbrs::rt::PackedBool,
        packed_nested_enum: pbrs::rt::PackedI32,
        unpacked_int32: Repeated<i32>,
        unpacked_int64: Repeated<i64>,
        unpacked_uint32: Repeated<u32>,
        unpacked_uint64: Repeated<u64>,
        unpacked_sint32: Repeated<i32>,
        unpacked_sint64: Repeated<i64>,
        unpacked_fixed32: Repeated<u32>,
        unpacked_fixed64: Repeated<u64>,
        unpacked_sfixed32: Repeated<i32>,
        unpacked_sfixed64: Repeated<i64>,
        unpacked_float: Repeated<f32>,
        unpacked_double: Repeated<f64>,
        unpacked_bool: Repeated<bool>,
        unpacked_nested_enum: Repeated<i32>,
        optional_bool_wrapper: pbrs::rt::LazyMsg<BoolValue>,
        optional_int32_wrapper: pbrs::rt::LazyMsg<Int32Value>,
        optional_int64_wrapper: pbrs::rt::LazyMsg<Int64Value>,
        optional_uint32_wrapper: pbrs::rt::LazyMsg<UInt32Value>,
        optional_uint64_wrapper: pbrs::rt::LazyMsg<UInt64Value>,
        optional_float_wrapper: pbrs::rt::LazyMsg<FloatValue>,
        optional_double_wrapper: pbrs::rt::LazyMsg<DoubleValue>,
        optional_string_wrapper: pbrs::rt::LazyMsg<StringValue>,
        optional_bytes_wrapper: pbrs::rt::LazyMsg<BytesValue>,
        repeated_bool_wrapper: Repeated<BoolValue>,
        repeated_int32_wrapper: Repeated<Int32Value>,
        repeated_int64_wrapper: Repeated<Int64Value>,
        repeated_uint32_wrapper: Repeated<UInt32Value>,
        repeated_uint64_wrapper: Repeated<UInt64Value>,
        repeated_float_wrapper: Repeated<FloatValue>,
        repeated_double_wrapper: Repeated<DoubleValue>,
        repeated_string_wrapper: Repeated<StringValue>,
        repeated_bytes_wrapper: Repeated<BytesValue>,
        optional_duration: pbrs::rt::LazyMsg<Duration>,
        optional_timestamp: pbrs::rt::LazyMsg<Timestamp>,
        optional_field_mask: pbrs::rt::LazyMsg<FieldMask>,
        optional_struct: pbrs::rt::LazyMsg<Struct>,
        optional_any: pbrs::rt::LazyMsg<Any>,
        optional_value: pbrs::rt::LazyMsg<PbValue>,
        optional_empty: pbrs::rt::LazyMsg<Empty>,
        repeated_duration: Repeated<Duration>,
        repeated_timestamp: Repeated<Timestamp>,
        repeated_fieldmask: Repeated<FieldMask>,
        repeated_any: Repeated<Any>,
        repeated_value: Repeated<PbValue>,
        repeated_list_value: Repeated<ListValue>,
        repeated_empty: Repeated<Empty>,
        repeated_struct: Repeated<Struct>,
    }
    impl Default for TestAllTypesProto3Cold {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TestAllTypesProto3 {
        optional_int32: i32,
        optional_int64: i64,
        optional_uint32: u32,
        optional_uint64: u64,
        optional_sint32: i32,
        optional_sint64: i64,
        optional_fixed32: u32,
        optional_fixed64: u64,
        optional_sfixed32: i32,
        optional_sfixed64: i64,
        optional_float: f32,
        optional_double: f64,
        optional_bool: bool,
        optional_string: pbrs::rt::LazyStr,
        optional_bytes: pbrs::rt::LazyBytes,
        optional_nested_message: pbrs::rt::LazyMsg<NestedMessage>,
        optional_foreign_message: pbrs::rt::LazyMsg<ForeignMessage>,
        optional_nested_enum: i32,
        optional_foreign_enum: i32,
        optional_aliased_enum: i32,
        optional_string_piece: pbrs::rt::LazyStr,
        optional_cord: pbrs::rt::LazyStr,
        recursive_message: pbrs::rt::LazyMsg<TestAllTypesProto3>,
        repeated_string: Repeated<pbrs::rt::LazyStr>,
        repeated_bytes: Repeated<pbrs::rt::LazyBytes>,
        repeated_nested_message: Repeated<NestedMessage>,
        repeated_string_piece: Repeated<pbrs::rt::LazyStr>,
        repeated_cord: Repeated<pbrs::rt::LazyStr>,
        map_int32_int32: Map<i32, i32>,
        map_int64_int64: Map<i64, i64>,
        map_uint32_uint32: Map<u32, u32>,
        map_uint64_uint64: Map<u64, u64>,
        map_sint32_sint32: Map<i32, i32>,
        map_sint64_sint64: Map<i64, i64>,
        map_fixed32_fixed32: Map<u32, u32>,
        map_fixed64_fixed64: Map<u64, u64>,
        map_sfixed32_sfixed32: Map<i32, i32>,
        map_sfixed64_sfixed64: Map<i64, i64>,
        map_int32_float: Map<i32, f32>,
        map_int32_double: Map<i32, f64>,
        map_bool_bool: Map<bool, bool>,
        map_string_string: Map<pbrs::rt::LazyStr, pbrs::rt::LazyStr>,
        map_string_bytes: Map<pbrs::rt::LazyStr, pbrs::rt::LazyBytes>,
        map_string_nested_message: Map<pbrs::rt::LazyStr, NestedMessage>,
        map_string_foreign_message: Map<pbrs::rt::LazyStr, ForeignMessage>,
        map_string_nested_enum: Map<pbrs::rt::LazyStr, i32>,
        map_string_foreign_enum: Map<pbrs::rt::LazyStr, i32>,
        packed_fixed32: pbrs::rt::PackedFx32,
        packed_fixed64: pbrs::rt::PackedFx64,
        packed_float: pbrs::rt::PackedF32,
        oneof_uint32: Option<u32>,
        oneof_nested_message: pbrs::rt::LazyMsg<NestedMessage>,
        oneof_string: Option<Box<pbrs::rt::LazyStr>>,
        oneof_bytes: Option<Box<pbrs::rt::LazyBytes>>,
        oneof_bool: pbrs::rt::OptBool,
        oneof_uint64: Option<u64>,
        oneof_float: Option<f32>,
        oneof_double: Option<f64>,
        oneof_enum: Option<i32>,
        oneof_null_value: Option<i32>,
        optional_null_value: i32,
        fieldname1: i32,
        field_name2: i32,
        _field_name3: i32,
        field__name4_: i32,
        field0name5: i32,
        field_0_name6: i32,
        fieldName7: i32,
        FieldName8: i32,
        field_Name9: i32,
        Field_Name10: i32,
        FIELD_NAME11: i32,
        FIELD_name12: i32,
        __field_name13: i32,
        __Field_name14: i32,
        field__name15: i32,
        field__Name16: i32,
        field_name17__: i32,
        Field_name18__: i32,
        cold: Option<Box<TestAllTypesProto3Cold>>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for TestAllTypesProto3 {
        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_aliased_enum != other.optional_aliased_enum {
                return false;
            }
            if self.optional_string_piece != other.optional_string_piece {
                return false;
            }
            if self.optional_cord != other.optional_cord {
                return false;
            }
            if self.recursive_message != other.recursive_message {
                return false;
            }
            if self.repeated_string != other.repeated_string {
                return false;
            }
            if self.repeated_bytes != other.repeated_bytes {
                return false;
            }
            if self.repeated_nested_message != other.repeated_nested_message {
                return false;
            }
            if self.repeated_string_piece != other.repeated_string_piece {
                return false;
            }
            if self.repeated_cord != other.repeated_cord {
                return false;
            }
            if self.map_int32_int32 != other.map_int32_int32 {
                return false;
            }
            if self.map_int64_int64 != other.map_int64_int64 {
                return false;
            }
            if self.map_uint32_uint32 != other.map_uint32_uint32 {
                return false;
            }
            if self.map_uint64_uint64 != other.map_uint64_uint64 {
                return false;
            }
            if self.map_sint32_sint32 != other.map_sint32_sint32 {
                return false;
            }
            if self.map_sint64_sint64 != other.map_sint64_sint64 {
                return false;
            }
            if self.map_fixed32_fixed32 != other.map_fixed32_fixed32 {
                return false;
            }
            if self.map_fixed64_fixed64 != other.map_fixed64_fixed64 {
                return false;
            }
            if self.map_sfixed32_sfixed32 != other.map_sfixed32_sfixed32 {
                return false;
            }
            if self.map_sfixed64_sfixed64 != other.map_sfixed64_sfixed64 {
                return false;
            }
            if self.map_int32_float != other.map_int32_float {
                return false;
            }
            if self.map_int32_double != other.map_int32_double {
                return false;
            }
            if self.map_bool_bool != other.map_bool_bool {
                return false;
            }
            if self.map_string_string != other.map_string_string {
                return false;
            }
            if self.map_string_bytes != other.map_string_bytes {
                return false;
            }
            if self.map_string_nested_message != other.map_string_nested_message {
                return false;
            }
            if self.map_string_foreign_message != other.map_string_foreign_message {
                return false;
            }
            if self.map_string_nested_enum != other.map_string_nested_enum {
                return false;
            }
            if self.map_string_foreign_enum != other.map_string_foreign_enum {
                return false;
            }
            if self.packed_fixed32 != other.packed_fixed32 {
                return false;
            }
            if self.packed_fixed64 != other.packed_fixed64 {
                return false;
            }
            if self.packed_float != other.packed_float {
                return false;
            }
            if self.oneof_uint32 != other.oneof_uint32 {
                return false;
            }
            if self.oneof_nested_message != other.oneof_nested_message {
                return false;
            }
            if self.oneof_string != other.oneof_string {
                return false;
            }
            if self.oneof_bytes != other.oneof_bytes {
                return false;
            }
            if self.oneof_bool != other.oneof_bool {
                return false;
            }
            if self.oneof_uint64 != other.oneof_uint64 {
                return false;
            }
            if self.oneof_float != other.oneof_float {
                return false;
            }
            if self.oneof_double != other.oneof_double {
                return false;
            }
            if self.oneof_enum != other.oneof_enum {
                return false;
            }
            if self.oneof_null_value != other.oneof_null_value {
                return false;
            }
            if self.optional_null_value != other.optional_null_value {
                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;
            }
            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 != TestAllTypesProto3Cold::default() {
                        return false;
                    }
                }
                (Some(a), None) => {
                    if *a != TestAllTypesProto3Cold::default() {
                        return false;
                    }
                }
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for TestAllTypesProto3 {}
    impl Default for TestAllTypesProto3 {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl TestAllTypesProto3 {
        pub fn new() -> Self {
            Self::default()
        }
        #[inline(always)]
        fn cold_mut(&mut self) -> &mut TestAllTypesProto3Cold {
            self.cold
                .get_or_insert_with(|| Box::new(TestAllTypesProto3Cold::default()))
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str = "protobuf_test_messages.proto3.TestAllTypesProto3";
        pub fn optional_int32(&self) -> i32 {
            self.optional_int32
        }
        pub fn set_optional_int32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.optional_int32 = v;
        }
        pub fn optional_int64(&self) -> i64 {
            self.optional_int64
        }
        pub fn set_optional_int64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.optional_int64 = v;
        }
        pub fn optional_uint32(&self) -> u32 {
            self.optional_uint32
        }
        pub fn set_optional_uint32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.optional_uint32 = v;
        }
        pub fn optional_uint64(&self) -> u64 {
            self.optional_uint64
        }
        pub fn set_optional_uint64(&mut self, v: u64) {
            self.cached_size.dirty();
            self.optional_uint64 = v;
        }
        pub fn optional_sint32(&self) -> i32 {
            self.optional_sint32
        }
        pub fn set_optional_sint32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.optional_sint32 = v;
        }
        pub fn optional_sint64(&self) -> i64 {
            self.optional_sint64
        }
        pub fn set_optional_sint64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.optional_sint64 = v;
        }
        pub fn optional_fixed32(&self) -> u32 {
            self.optional_fixed32
        }
        pub fn set_optional_fixed32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.optional_fixed32 = v;
        }
        pub fn optional_fixed64(&self) -> u64 {
            self.optional_fixed64
        }
        pub fn set_optional_fixed64(&mut self, v: u64) {
            self.cached_size.dirty();
            self.optional_fixed64 = v;
        }
        pub fn optional_sfixed32(&self) -> i32 {
            self.optional_sfixed32
        }
        pub fn set_optional_sfixed32(&mut self, v: i32) {
            self.cached_size.dirty();
            self.optional_sfixed32 = v;
        }
        pub fn optional_sfixed64(&self) -> i64 {
            self.optional_sfixed64
        }
        pub fn set_optional_sfixed64(&mut self, v: i64) {
            self.cached_size.dirty();
            self.optional_sfixed64 = v;
        }
        pub fn optional_float(&self) -> f32 {
            self.optional_float
        }
        pub fn set_optional_float(&mut self, v: f32) {
            self.cached_size.dirty();
            self.optional_float = v;
        }
        pub fn optional_double(&self) -> f64 {
            self.optional_double
        }
        pub fn set_optional_double(&mut self, v: f64) {
            self.cached_size.dirty();
            self.optional_double = v;
        }
        pub fn optional_bool(&self) -> bool {
            self.optional_bool
        }
        pub fn set_optional_bool(&mut self, v: bool) {
            self.cached_size.dirty();
            self.optional_bool = v;
        }
        pub fn optional_string(&self) -> &pbrs::ProtoStr {
            self.optional_string.as_view()
        }
        pub fn set_optional_string(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.optional_string =
                pbrs::rt::LazyStr::owned(v.into_proxied(pbrs::__internal::Private));
        }
        pub fn optional_bytes(&self) -> &[u8] {
            self.optional_bytes.as_bytes()
        }
        pub fn set_optional_bytes(&mut self, v: impl pbrs::IntoProxied<ProtoBytes>) {
            self.cached_size.dirty();
            self.optional_bytes =
                pbrs::rt::LazyBytes::owned(v.into_proxied(pbrs::__internal::Private));
        }
        pub fn has_optional_nested_message(&self) -> bool {
            self.optional_nested_message.is_some()
        }
        pub fn optional_nested_message(&self) -> &NestedMessage {
            self.optional_nested_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_nested_message_opt(&self) -> Option<&NestedMessage> {
            self.optional_nested_message.as_deref()
        }
        pub fn optional_nested_message_view(&self) -> NestedMessageView<'_> {
            NestedMessageView(self.optional_nested_message())
        }
        pub fn set_optional_nested_message(&mut self, v: NestedMessage) {
            self.cached_size.dirty();
            self.optional_nested_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_nested_message_mut(&mut self) -> &mut NestedMessage {
            self.cached_size.dirty();
            self.optional_nested_message.get_or_insert()
        }
        pub fn clear_optional_nested_message(&mut self) {
            self.cached_size.dirty();
            self.optional_nested_message.clear();
        }
        pub fn has_optional_foreign_message(&self) -> bool {
            self.optional_foreign_message.is_some()
        }
        pub fn optional_foreign_message(&self) -> &ForeignMessage {
            self.optional_foreign_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_foreign_message_opt(&self) -> Option<&ForeignMessage> {
            self.optional_foreign_message.as_deref()
        }
        pub fn optional_foreign_message_view(&self) -> ForeignMessageView<'_> {
            ForeignMessageView(self.optional_foreign_message())
        }
        pub fn set_optional_foreign_message(&mut self, v: ForeignMessage) {
            self.cached_size.dirty();
            self.optional_foreign_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_foreign_message_mut(&mut self) -> &mut ForeignMessage {
            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 optional_nested_enum(&self) -> NestedEnum {
            NestedEnum(self.optional_nested_enum)
        }
        pub fn set_optional_nested_enum(&mut self, v: impl Into<i32>) {
            self.cached_size.dirty();
            self.optional_nested_enum = v.into();
        }
        pub fn optional_foreign_enum(&self) -> ForeignEnum {
            ForeignEnum(self.optional_foreign_enum)
        }
        pub fn set_optional_foreign_enum(&mut self, v: impl Into<i32>) {
            self.cached_size.dirty();
            self.optional_foreign_enum = v.into();
        }
        pub fn optional_aliased_enum(&self) -> AliasedEnum {
            AliasedEnum(self.optional_aliased_enum)
        }
        pub fn set_optional_aliased_enum(&mut self, v: impl Into<i32>) {
            self.cached_size.dirty();
            self.optional_aliased_enum = v.into();
        }
        pub fn optional_string_piece(&self) -> &pbrs::ProtoStr {
            self.optional_string_piece.as_view()
        }
        pub fn set_optional_string_piece(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.optional_string_piece =
                pbrs::rt::LazyStr::owned(v.into_proxied(pbrs::__internal::Private));
        }
        pub fn optional_cord(&self) -> &pbrs::ProtoStr {
            self.optional_cord.as_view()
        }
        pub fn set_optional_cord(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.optional_cord =
                pbrs::rt::LazyStr::owned(v.into_proxied(pbrs::__internal::Private));
        }
        pub fn has_recursive_message(&self) -> bool {
            self.recursive_message.is_some()
        }
        pub fn recursive_message(&self) -> &TestAllTypesProto3 {
            self.recursive_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn recursive_message_opt(&self) -> Option<&TestAllTypesProto3> {
            self.recursive_message.as_deref()
        }
        pub fn recursive_message_view(&self) -> TestAllTypesProto3View<'_> {
            TestAllTypesProto3View(self.recursive_message())
        }
        pub fn set_recursive_message(&mut self, v: TestAllTypesProto3) {
            self.cached_size.dirty();
            self.recursive_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn recursive_message_mut(&mut self) -> &mut TestAllTypesProto3 {
            self.cached_size.dirty();
            self.recursive_message.get_or_insert()
        }
        pub fn clear_recursive_message(&mut self) {
            self.cached_size.dirty();
            self.recursive_message.clear();
        }
        pub fn repeated_int32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_int32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_int32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_int32.as_mut()
        }
        pub fn set_repeated_int32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_int32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_int64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_int64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_int64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_int64.as_mut()
        }
        pub fn set_repeated_int64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_int64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_uint32(&self) -> RepeatedView<'_, u32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_uint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_uint32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint32.as_mut()
        }
        pub fn set_repeated_uint32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_uint64(&self) -> RepeatedView<'_, u64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_uint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_uint64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint64.as_mut()
        }
        pub fn set_repeated_uint64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_sint32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_sint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_sint32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_sint32.as_mut()
        }
        pub fn set_repeated_sint32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_sint32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_sint64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_sint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_sint64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_sint64.as_mut()
        }
        pub fn set_repeated_sint64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_sint64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_fixed32(&self) -> RepeatedView<'_, u32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_fixed32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_fixed32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_fixed32.as_mut()
        }
        pub fn set_repeated_fixed32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_fixed32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_fixed64(&self) -> RepeatedView<'_, u64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_fixed64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_fixed64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_fixed64.as_mut()
        }
        pub fn set_repeated_fixed64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_fixed64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_sfixed32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_sfixed32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_sfixed32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_sfixed32.as_mut()
        }
        pub fn set_repeated_sfixed32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_sfixed32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_sfixed64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_sfixed64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_sfixed64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_sfixed64.as_mut()
        }
        pub fn set_repeated_sfixed64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_sfixed64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_float(&self) -> RepeatedView<'_, f32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_float.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_float_mut(&mut self) -> RepeatedMut<'_, f32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_float.as_mut()
        }
        pub fn set_repeated_float(&mut self, v: impl IntoIterator<Item = f32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_float =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_double(&self) -> RepeatedView<'_, f64> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_double.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_double_mut(&mut self) -> RepeatedMut<'_, f64> {
            self.cached_size.dirty();
            self.cold_mut().repeated_double.as_mut()
        }
        pub fn set_repeated_double(&mut self, v: impl IntoIterator<Item = f64>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_double =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_bool(&self) -> RepeatedView<'_, bool> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_bool.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_bool_mut(&mut self) -> RepeatedMut<'_, bool> {
            self.cached_size.dirty();
            self.cold_mut().repeated_bool.as_mut()
        }
        pub fn set_repeated_bool(&mut self, v: impl IntoIterator<Item = bool>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_bool =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_string(&self) -> RepeatedView<'_, pbrs::rt::LazyStr> {
            self.repeated_string.as_view()
        }
        pub fn repeated_string_mut(&mut self) -> RepeatedMut<'_, pbrs::rt::LazyStr> {
            self.cached_size.dirty();
            self.repeated_string.as_mut()
        }
        pub fn set_repeated_string(&mut self, v: impl IntoIterator<Item = pbrs::rt::LazyStr>) {
            self.cached_size.dirty();
            self.repeated_string = v.into_iter().collect();
        }
        pub fn repeated_bytes(&self) -> RepeatedView<'_, pbrs::rt::LazyBytes> {
            self.repeated_bytes.as_view()
        }
        pub fn repeated_bytes_mut(&mut self) -> RepeatedMut<'_, pbrs::rt::LazyBytes> {
            self.cached_size.dirty();
            self.repeated_bytes.as_mut()
        }
        pub fn set_repeated_bytes(&mut self, v: impl IntoIterator<Item = pbrs::rt::LazyBytes>) {
            self.cached_size.dirty();
            self.repeated_bytes = v.into_iter().collect();
        }
        pub fn repeated_nested_message(&self) -> RepeatedView<'_, NestedMessage> {
            self.repeated_nested_message.as_view()
        }
        pub fn repeated_nested_message_mut(&mut self) -> RepeatedMut<'_, NestedMessage> {
            self.cached_size.dirty();
            self.repeated_nested_message.as_mut()
        }
        pub fn set_repeated_nested_message(&mut self, v: impl IntoIterator<Item = NestedMessage>) {
            self.cached_size.dirty();
            self.repeated_nested_message = v.into_iter().collect();
        }
        pub fn repeated_foreign_message(&self) -> RepeatedView<'_, ForeignMessage> {
            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<'_, ForeignMessage> {
            self.cached_size.dirty();
            self.cold_mut().repeated_foreign_message.as_mut()
        }
        pub fn set_repeated_foreign_message(
            &mut self,
            v: impl IntoIterator<Item = ForeignMessage>,
        ) {
            self.cached_size.dirty();
            self.cold_mut().repeated_foreign_message = v.into_iter().collect();
        }
        pub fn repeated_nested_enum(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_nested_enum.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_nested_enum_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_nested_enum.as_mut()
        }
        pub fn set_repeated_nested_enum(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_nested_enum =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_foreign_enum(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_foreign_enum.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_foreign_enum_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().repeated_foreign_enum.as_mut()
        }
        pub fn set_repeated_foreign_enum(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_foreign_enum =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn repeated_string_piece(&self) -> RepeatedView<'_, pbrs::rt::LazyStr> {
            self.repeated_string_piece.as_view()
        }
        pub fn repeated_string_piece_mut(&mut self) -> RepeatedMut<'_, pbrs::rt::LazyStr> {
            self.cached_size.dirty();
            self.repeated_string_piece.as_mut()
        }
        pub fn set_repeated_string_piece(
            &mut self,
            v: impl IntoIterator<Item = pbrs::rt::LazyStr>,
        ) {
            self.cached_size.dirty();
            self.repeated_string_piece = v.into_iter().collect();
        }
        pub fn repeated_cord(&self) -> RepeatedView<'_, pbrs::rt::LazyStr> {
            self.repeated_cord.as_view()
        }
        pub fn repeated_cord_mut(&mut self) -> RepeatedMut<'_, pbrs::rt::LazyStr> {
            self.cached_size.dirty();
            self.repeated_cord.as_mut()
        }
        pub fn set_repeated_cord(&mut self, v: impl IntoIterator<Item = pbrs::rt::LazyStr>) {
            self.cached_size.dirty();
            self.repeated_cord = v.into_iter().collect();
        }
        pub fn map_int32_int32(&self) -> MapView<'_, i32, i32> {
            self.map_int32_int32.as_view()
        }
        pub fn map_int32_int32_mut(&mut self) -> MapMut<'_, i32, i32> {
            self.cached_size.dirty();
            self.map_int32_int32.as_mut()
        }
        pub fn set_map_int32_int32(&mut self, v: Map<i32, i32>) {
            self.cached_size.dirty();
            self.map_int32_int32 = v;
        }
        pub fn map_int64_int64(&self) -> MapView<'_, i64, i64> {
            self.map_int64_int64.as_view()
        }
        pub fn map_int64_int64_mut(&mut self) -> MapMut<'_, i64, i64> {
            self.cached_size.dirty();
            self.map_int64_int64.as_mut()
        }
        pub fn set_map_int64_int64(&mut self, v: Map<i64, i64>) {
            self.cached_size.dirty();
            self.map_int64_int64 = v;
        }
        pub fn map_uint32_uint32(&self) -> MapView<'_, u32, u32> {
            self.map_uint32_uint32.as_view()
        }
        pub fn map_uint32_uint32_mut(&mut self) -> MapMut<'_, u32, u32> {
            self.cached_size.dirty();
            self.map_uint32_uint32.as_mut()
        }
        pub fn set_map_uint32_uint32(&mut self, v: Map<u32, u32>) {
            self.cached_size.dirty();
            self.map_uint32_uint32 = v;
        }
        pub fn map_uint64_uint64(&self) -> MapView<'_, u64, u64> {
            self.map_uint64_uint64.as_view()
        }
        pub fn map_uint64_uint64_mut(&mut self) -> MapMut<'_, u64, u64> {
            self.cached_size.dirty();
            self.map_uint64_uint64.as_mut()
        }
        pub fn set_map_uint64_uint64(&mut self, v: Map<u64, u64>) {
            self.cached_size.dirty();
            self.map_uint64_uint64 = v;
        }
        pub fn map_sint32_sint32(&self) -> MapView<'_, i32, i32> {
            self.map_sint32_sint32.as_view()
        }
        pub fn map_sint32_sint32_mut(&mut self) -> MapMut<'_, i32, i32> {
            self.cached_size.dirty();
            self.map_sint32_sint32.as_mut()
        }
        pub fn set_map_sint32_sint32(&mut self, v: Map<i32, i32>) {
            self.cached_size.dirty();
            self.map_sint32_sint32 = v;
        }
        pub fn map_sint64_sint64(&self) -> MapView<'_, i64, i64> {
            self.map_sint64_sint64.as_view()
        }
        pub fn map_sint64_sint64_mut(&mut self) -> MapMut<'_, i64, i64> {
            self.cached_size.dirty();
            self.map_sint64_sint64.as_mut()
        }
        pub fn set_map_sint64_sint64(&mut self, v: Map<i64, i64>) {
            self.cached_size.dirty();
            self.map_sint64_sint64 = v;
        }
        pub fn map_fixed32_fixed32(&self) -> MapView<'_, u32, u32> {
            self.map_fixed32_fixed32.as_view()
        }
        pub fn map_fixed32_fixed32_mut(&mut self) -> MapMut<'_, u32, u32> {
            self.cached_size.dirty();
            self.map_fixed32_fixed32.as_mut()
        }
        pub fn set_map_fixed32_fixed32(&mut self, v: Map<u32, u32>) {
            self.cached_size.dirty();
            self.map_fixed32_fixed32 = v;
        }
        pub fn map_fixed64_fixed64(&self) -> MapView<'_, u64, u64> {
            self.map_fixed64_fixed64.as_view()
        }
        pub fn map_fixed64_fixed64_mut(&mut self) -> MapMut<'_, u64, u64> {
            self.cached_size.dirty();
            self.map_fixed64_fixed64.as_mut()
        }
        pub fn set_map_fixed64_fixed64(&mut self, v: Map<u64, u64>) {
            self.cached_size.dirty();
            self.map_fixed64_fixed64 = v;
        }
        pub fn map_sfixed32_sfixed32(&self) -> MapView<'_, i32, i32> {
            self.map_sfixed32_sfixed32.as_view()
        }
        pub fn map_sfixed32_sfixed32_mut(&mut self) -> MapMut<'_, i32, i32> {
            self.cached_size.dirty();
            self.map_sfixed32_sfixed32.as_mut()
        }
        pub fn set_map_sfixed32_sfixed32(&mut self, v: Map<i32, i32>) {
            self.cached_size.dirty();
            self.map_sfixed32_sfixed32 = v;
        }
        pub fn map_sfixed64_sfixed64(&self) -> MapView<'_, i64, i64> {
            self.map_sfixed64_sfixed64.as_view()
        }
        pub fn map_sfixed64_sfixed64_mut(&mut self) -> MapMut<'_, i64, i64> {
            self.cached_size.dirty();
            self.map_sfixed64_sfixed64.as_mut()
        }
        pub fn set_map_sfixed64_sfixed64(&mut self, v: Map<i64, i64>) {
            self.cached_size.dirty();
            self.map_sfixed64_sfixed64 = v;
        }
        pub fn map_int32_float(&self) -> MapView<'_, i32, f32> {
            self.map_int32_float.as_view()
        }
        pub fn map_int32_float_mut(&mut self) -> MapMut<'_, i32, f32> {
            self.cached_size.dirty();
            self.map_int32_float.as_mut()
        }
        pub fn set_map_int32_float(&mut self, v: Map<i32, f32>) {
            self.cached_size.dirty();
            self.map_int32_float = v;
        }
        pub fn map_int32_double(&self) -> MapView<'_, i32, f64> {
            self.map_int32_double.as_view()
        }
        pub fn map_int32_double_mut(&mut self) -> MapMut<'_, i32, f64> {
            self.cached_size.dirty();
            self.map_int32_double.as_mut()
        }
        pub fn set_map_int32_double(&mut self, v: Map<i32, f64>) {
            self.cached_size.dirty();
            self.map_int32_double = v;
        }
        pub fn map_bool_bool(&self) -> MapView<'_, bool, bool> {
            self.map_bool_bool.as_view()
        }
        pub fn map_bool_bool_mut(&mut self) -> MapMut<'_, bool, bool> {
            self.cached_size.dirty();
            self.map_bool_bool.as_mut()
        }
        pub fn set_map_bool_bool(&mut self, v: Map<bool, bool>) {
            self.cached_size.dirty();
            self.map_bool_bool = v;
        }
        pub fn map_string_string(&self) -> MapView<'_, pbrs::rt::LazyStr, pbrs::rt::LazyStr> {
            self.map_string_string.as_view()
        }
        pub fn map_string_string_mut(
            &mut self,
        ) -> MapMut<'_, pbrs::rt::LazyStr, pbrs::rt::LazyStr> {
            self.cached_size.dirty();
            self.map_string_string.as_mut()
        }
        pub fn set_map_string_string(&mut self, v: Map<pbrs::rt::LazyStr, pbrs::rt::LazyStr>) {
            self.cached_size.dirty();
            self.map_string_string = v;
        }
        pub fn map_string_bytes(&self) -> MapView<'_, pbrs::rt::LazyStr, pbrs::rt::LazyBytes> {
            self.map_string_bytes.as_view()
        }
        pub fn map_string_bytes_mut(
            &mut self,
        ) -> MapMut<'_, pbrs::rt::LazyStr, pbrs::rt::LazyBytes> {
            self.cached_size.dirty();
            self.map_string_bytes.as_mut()
        }
        pub fn set_map_string_bytes(&mut self, v: Map<pbrs::rt::LazyStr, pbrs::rt::LazyBytes>) {
            self.cached_size.dirty();
            self.map_string_bytes = v;
        }
        pub fn map_string_nested_message(&self) -> MapView<'_, pbrs::rt::LazyStr, NestedMessage> {
            self.map_string_nested_message.as_view()
        }
        pub fn map_string_nested_message_mut(
            &mut self,
        ) -> MapMut<'_, pbrs::rt::LazyStr, NestedMessage> {
            self.cached_size.dirty();
            self.map_string_nested_message.as_mut()
        }
        pub fn set_map_string_nested_message(&mut self, v: Map<pbrs::rt::LazyStr, NestedMessage>) {
            self.cached_size.dirty();
            self.map_string_nested_message = v;
        }
        pub fn map_string_foreign_message(&self) -> MapView<'_, pbrs::rt::LazyStr, ForeignMessage> {
            self.map_string_foreign_message.as_view()
        }
        pub fn map_string_foreign_message_mut(
            &mut self,
        ) -> MapMut<'_, pbrs::rt::LazyStr, ForeignMessage> {
            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, ForeignMessage>,
        ) {
            self.cached_size.dirty();
            self.map_string_foreign_message = v;
        }
        pub fn map_string_nested_enum(&self) -> MapView<'_, pbrs::rt::LazyStr, i32> {
            self.map_string_nested_enum.as_view()
        }
        pub fn map_string_nested_enum_mut(&mut self) -> MapMut<'_, pbrs::rt::LazyStr, i32> {
            self.cached_size.dirty();
            self.map_string_nested_enum.as_mut()
        }
        pub fn set_map_string_nested_enum(&mut self, v: Map<pbrs::rt::LazyStr, i32>) {
            self.cached_size.dirty();
            self.map_string_nested_enum = v;
        }
        pub fn map_string_foreign_enum(&self) -> MapView<'_, pbrs::rt::LazyStr, i32> {
            self.map_string_foreign_enum.as_view()
        }
        pub fn map_string_foreign_enum_mut(&mut self) -> MapMut<'_, pbrs::rt::LazyStr, i32> {
            self.cached_size.dirty();
            self.map_string_foreign_enum.as_mut()
        }
        pub fn set_map_string_foreign_enum(&mut self, v: Map<pbrs::rt::LazyStr, i32>) {
            self.cached_size.dirty();
            self.map_string_foreign_enum = v;
        }
        pub fn packed_int32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.packed_int32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_int32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().packed_int32.as_mut()
        }
        pub fn set_packed_int32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().packed_int32 = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_int64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.packed_int64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_int64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().packed_int64.as_mut()
        }
        pub fn set_packed_int64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().packed_int64 = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_uint32(&self) -> RepeatedView<'_, u32> {
            self.cold
                .as_ref()
                .map(|c| c.packed_uint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_uint32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.cold_mut().packed_uint32.as_mut()
        }
        pub fn set_packed_uint32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.cold_mut().packed_uint32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_uint64(&self) -> RepeatedView<'_, u64> {
            self.cold
                .as_ref()
                .map(|c| c.packed_uint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_uint64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.cold_mut().packed_uint64.as_mut()
        }
        pub fn set_packed_uint64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.cold_mut().packed_uint64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_sint32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.packed_sint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_sint32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().packed_sint32.as_mut()
        }
        pub fn set_packed_sint32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().packed_sint32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_sint64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.packed_sint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_sint64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().packed_sint64.as_mut()
        }
        pub fn set_packed_sint64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().packed_sint64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_fixed32(&self) -> RepeatedView<'_, u32> {
            self.packed_fixed32.as_view()
        }
        pub fn packed_fixed32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.packed_fixed32.as_mut()
        }
        pub fn set_packed_fixed32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.packed_fixed32 = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_fixed64(&self) -> RepeatedView<'_, u64> {
            self.packed_fixed64.as_view()
        }
        pub fn packed_fixed64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.packed_fixed64.as_mut()
        }
        pub fn set_packed_fixed64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.packed_fixed64 = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_sfixed32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.packed_sfixed32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_sfixed32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().packed_sfixed32.as_mut()
        }
        pub fn set_packed_sfixed32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().packed_sfixed32 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_sfixed64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.packed_sfixed64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_sfixed64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().packed_sfixed64.as_mut()
        }
        pub fn set_packed_sfixed64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().packed_sfixed64 =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_float(&self) -> RepeatedView<'_, f32> {
            self.packed_float.as_view()
        }
        pub fn packed_float_mut(&mut self) -> RepeatedMut<'_, f32> {
            self.cached_size.dirty();
            self.packed_float.as_mut()
        }
        pub fn set_packed_float(&mut self, v: impl IntoIterator<Item = f32>) {
            self.cached_size.dirty();
            self.packed_float = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_double(&self) -> RepeatedView<'_, f64> {
            self.cold
                .as_ref()
                .map(|c| c.packed_double.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_double_mut(&mut self) -> RepeatedMut<'_, f64> {
            self.cached_size.dirty();
            self.cold_mut().packed_double.as_mut()
        }
        pub fn set_packed_double(&mut self, v: impl IntoIterator<Item = f64>) {
            self.cached_size.dirty();
            self.cold_mut().packed_double =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_bool(&self) -> RepeatedView<'_, bool> {
            self.cold
                .as_ref()
                .map(|c| c.packed_bool.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_bool_mut(&mut self) -> RepeatedMut<'_, bool> {
            self.cached_size.dirty();
            self.cold_mut().packed_bool.as_mut()
        }
        pub fn set_packed_bool(&mut self, v: impl IntoIterator<Item = bool>) {
            self.cached_size.dirty();
            self.cold_mut().packed_bool = pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn packed_nested_enum(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.packed_nested_enum.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn packed_nested_enum_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().packed_nested_enum.as_mut()
        }
        pub fn set_packed_nested_enum(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().packed_nested_enum =
                pbrs::rt::Packed::from_repeated(v.into_iter().collect());
        }
        pub fn unpacked_int32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_int32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_int32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_int32.as_mut()
        }
        pub fn set_unpacked_int32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_int32 = v.into_iter().collect();
        }
        pub fn unpacked_int64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_int64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_int64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_int64.as_mut()
        }
        pub fn set_unpacked_int64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_int64 = v.into_iter().collect();
        }
        pub fn unpacked_uint32(&self) -> RepeatedView<'_, u32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_uint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_uint32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_uint32.as_mut()
        }
        pub fn set_unpacked_uint32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_uint32 = v.into_iter().collect();
        }
        pub fn unpacked_uint64(&self) -> RepeatedView<'_, u64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_uint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_uint64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_uint64.as_mut()
        }
        pub fn set_unpacked_uint64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_uint64 = v.into_iter().collect();
        }
        pub fn unpacked_sint32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_sint32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_sint32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sint32.as_mut()
        }
        pub fn set_unpacked_sint32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sint32 = v.into_iter().collect();
        }
        pub fn unpacked_sint64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_sint64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_sint64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sint64.as_mut()
        }
        pub fn set_unpacked_sint64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sint64 = v.into_iter().collect();
        }
        pub fn unpacked_fixed32(&self) -> RepeatedView<'_, u32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_fixed32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_fixed32_mut(&mut self) -> RepeatedMut<'_, u32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_fixed32.as_mut()
        }
        pub fn set_unpacked_fixed32(&mut self, v: impl IntoIterator<Item = u32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_fixed32 = v.into_iter().collect();
        }
        pub fn unpacked_fixed64(&self) -> RepeatedView<'_, u64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_fixed64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_fixed64_mut(&mut self) -> RepeatedMut<'_, u64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_fixed64.as_mut()
        }
        pub fn set_unpacked_fixed64(&mut self, v: impl IntoIterator<Item = u64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_fixed64 = v.into_iter().collect();
        }
        pub fn unpacked_sfixed32(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_sfixed32.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_sfixed32_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sfixed32.as_mut()
        }
        pub fn set_unpacked_sfixed32(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sfixed32 = v.into_iter().collect();
        }
        pub fn unpacked_sfixed64(&self) -> RepeatedView<'_, i64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_sfixed64.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_sfixed64_mut(&mut self) -> RepeatedMut<'_, i64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sfixed64.as_mut()
        }
        pub fn set_unpacked_sfixed64(&mut self, v: impl IntoIterator<Item = i64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_sfixed64 = v.into_iter().collect();
        }
        pub fn unpacked_float(&self) -> RepeatedView<'_, f32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_float.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_float_mut(&mut self) -> RepeatedMut<'_, f32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_float.as_mut()
        }
        pub fn set_unpacked_float(&mut self, v: impl IntoIterator<Item = f32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_float = v.into_iter().collect();
        }
        pub fn unpacked_double(&self) -> RepeatedView<'_, f64> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_double.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_double_mut(&mut self) -> RepeatedMut<'_, f64> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_double.as_mut()
        }
        pub fn set_unpacked_double(&mut self, v: impl IntoIterator<Item = f64>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_double = v.into_iter().collect();
        }
        pub fn unpacked_bool(&self) -> RepeatedView<'_, bool> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_bool.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_bool_mut(&mut self) -> RepeatedMut<'_, bool> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_bool.as_mut()
        }
        pub fn set_unpacked_bool(&mut self, v: impl IntoIterator<Item = bool>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_bool = v.into_iter().collect();
        }
        pub fn unpacked_nested_enum(&self) -> RepeatedView<'_, i32> {
            self.cold
                .as_ref()
                .map(|c| c.unpacked_nested_enum.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn unpacked_nested_enum_mut(&mut self) -> RepeatedMut<'_, i32> {
            self.cached_size.dirty();
            self.cold_mut().unpacked_nested_enum.as_mut()
        }
        pub fn set_unpacked_nested_enum(&mut self, v: impl IntoIterator<Item = i32>) {
            self.cached_size.dirty();
            self.cold_mut().unpacked_nested_enum = v.into_iter().collect();
        }
        pub fn has_oneof_uint32(&self) -> bool {
            self.oneof_uint32.is_some()
        }
        pub fn oneof_uint32(&self) -> u32 {
            self.oneof_uint32.unwrap_or(0)
        }
        pub fn oneof_uint32_opt(&self) -> Option<u32> {
            self.oneof_uint32.map(|v| v)
        }
        pub fn set_oneof_uint32(&mut self, v: u32) {
            self.cached_size.dirty();
            self.oneof_nested_message = Default::default();
            self.oneof_string = None;
            self.oneof_bytes = None;
            self.oneof_bool = pbrs::rt::OptBool::NONE;
            self.oneof_uint64 = None;
            self.oneof_float = None;
            self.oneof_double = None;
            self.oneof_enum = None;
            self.oneof_null_value = None;
            self.oneof_uint32 = Some(v);
        }
        pub fn clear_oneof_uint32(&mut self) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
        }
        pub fn has_oneof_nested_message(&self) -> bool {
            self.oneof_nested_message.is_some()
        }
        pub fn oneof_nested_message(&self) -> &NestedMessage {
            self.oneof_nested_message
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn oneof_nested_message_opt(&self) -> Option<&NestedMessage> {
            self.oneof_nested_message.as_deref()
        }
        pub fn oneof_nested_message_view(&self) -> NestedMessageView<'_> {
            NestedMessageView(self.oneof_nested_message())
        }
        pub fn set_oneof_nested_message(&mut self, v: NestedMessage) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
            self.oneof_string = None;
            self.oneof_bytes = None;
            self.oneof_bool = pbrs::rt::OptBool::NONE;
            self.oneof_uint64 = None;
            self.oneof_float = None;
            self.oneof_double = None;
            self.oneof_enum = None;
            self.oneof_null_value = None;
            self.oneof_nested_message = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn oneof_nested_message_mut(&mut self) -> &mut NestedMessage {
            self.cached_size.dirty();
            self.oneof_nested_message.get_or_insert()
        }
        pub fn clear_oneof_nested_message(&mut self) {
            self.cached_size.dirty();
            self.oneof_nested_message.clear();
        }
        pub fn has_oneof_string(&self) -> bool {
            self.oneof_string.is_some()
        }
        pub fn oneof_string(&self) -> &pbrs::ProtoStr {
            self.oneof_string
                .as_ref()
                .map(|s| s.as_view())
                .unwrap_or_else(|| pbrs::ProtoStr::from_bytes(b""))
        }
        pub fn oneof_string_opt(&self) -> Option<&pbrs::ProtoStr> {
            self.oneof_string.as_ref().map(|s| s.as_view())
        }
        pub fn set_oneof_string(&mut self, v: impl pbrs::IntoProxied<ProtoString>) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
            self.oneof_nested_message = Default::default();
            self.oneof_bytes = None;
            self.oneof_bool = pbrs::rt::OptBool::NONE;
            self.oneof_uint64 = None;
            self.oneof_float = None;
            self.oneof_double = None;
            self.oneof_enum = None;
            self.oneof_null_value = 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_null_value = 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_null_value = 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_null_value = 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_null_value = None;
            self.oneof_double = Some(v);
        }
        pub fn clear_oneof_double(&mut self) {
            self.cached_size.dirty();
            self.oneof_double = None;
        }
        pub fn has_oneof_enum(&self) -> bool {
            self.oneof_enum.is_some()
        }
        pub fn oneof_enum(&self) -> NestedEnum {
            NestedEnum(self.oneof_enum.unwrap_or(0))
        }
        pub fn oneof_enum_opt(&self) -> Option<NestedEnum> {
            self.oneof_enum.map(|v| NestedEnum(v))
        }
        pub fn set_oneof_enum(&mut self, v: impl Into<i32>) {
            self.cached_size.dirty();
            self.oneof_uint32 = None;
            self.oneof_nested_message = Default::default();
            self.oneof_string = None;
            self.oneof_bytes = None;
            self.oneof_bool = pbrs::rt::OptBool::NONE;
            self.oneof_uint64 = None;
            self.oneof_float = None;
            self.oneof_double = None;
            self.oneof_null_value = 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_oneof_null_value(&self) -> bool {
            self.oneof_null_value.is_some()
        }
        pub fn oneof_null_value(&self) -> NullValue {
            NullValue(self.oneof_null_value.unwrap_or(0))
        }
        pub fn oneof_null_value_opt(&self) -> Option<NullValue> {
            self.oneof_null_value.map(|v| NullValue(v))
        }
        pub fn set_oneof_null_value(&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 = None;
            self.oneof_null_value = Some(v.into());
        }
        pub fn clear_oneof_null_value(&mut self) {
            self.cached_size.dirty();
            self.oneof_null_value = None;
        }
        pub fn has_optional_bool_wrapper(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_bool_wrapper.is_some())
        }
        pub fn optional_bool_wrapper(&self) -> &BoolValue {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_bool_wrapper.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_bool_wrapper_opt(&self) -> Option<&BoolValue> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_bool_wrapper.as_deref())
        }
        pub fn optional_bool_wrapper_view(&self) -> BoolValueView<'_> {
            BoolValueView(self.optional_bool_wrapper())
        }
        pub fn set_optional_bool_wrapper(&mut self, v: BoolValue) {
            self.cached_size.dirty();
            self.cold_mut().optional_bool_wrapper = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_bool_wrapper_mut(&mut self) -> &mut BoolValue {
            self.cached_size.dirty();
            self.cold_mut().optional_bool_wrapper.get_or_insert()
        }
        pub fn clear_optional_bool_wrapper(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_bool_wrapper.clear();
        }
        pub fn has_optional_int32_wrapper(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_int32_wrapper.is_some())
        }
        pub fn optional_int32_wrapper(&self) -> &Int32Value {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_int32_wrapper.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_int32_wrapper_opt(&self) -> Option<&Int32Value> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_int32_wrapper.as_deref())
        }
        pub fn optional_int32_wrapper_view(&self) -> Int32ValueView<'_> {
            Int32ValueView(self.optional_int32_wrapper())
        }
        pub fn set_optional_int32_wrapper(&mut self, v: Int32Value) {
            self.cached_size.dirty();
            self.cold_mut().optional_int32_wrapper = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_int32_wrapper_mut(&mut self) -> &mut Int32Value {
            self.cached_size.dirty();
            self.cold_mut().optional_int32_wrapper.get_or_insert()
        }
        pub fn clear_optional_int32_wrapper(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_int32_wrapper.clear();
        }
        pub fn has_optional_int64_wrapper(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_int64_wrapper.is_some())
        }
        pub fn optional_int64_wrapper(&self) -> &Int64Value {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_int64_wrapper.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_int64_wrapper_opt(&self) -> Option<&Int64Value> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_int64_wrapper.as_deref())
        }
        pub fn optional_int64_wrapper_view(&self) -> Int64ValueView<'_> {
            Int64ValueView(self.optional_int64_wrapper())
        }
        pub fn set_optional_int64_wrapper(&mut self, v: Int64Value) {
            self.cached_size.dirty();
            self.cold_mut().optional_int64_wrapper = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_int64_wrapper_mut(&mut self) -> &mut Int64Value {
            self.cached_size.dirty();
            self.cold_mut().optional_int64_wrapper.get_or_insert()
        }
        pub fn clear_optional_int64_wrapper(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_int64_wrapper.clear();
        }
        pub fn has_optional_uint32_wrapper(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_uint32_wrapper.is_some())
        }
        pub fn optional_uint32_wrapper(&self) -> &UInt32Value {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_uint32_wrapper.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_uint32_wrapper_opt(&self) -> Option<&UInt32Value> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_uint32_wrapper.as_deref())
        }
        pub fn optional_uint32_wrapper_view(&self) -> UInt32ValueView<'_> {
            UInt32ValueView(self.optional_uint32_wrapper())
        }
        pub fn set_optional_uint32_wrapper(&mut self, v: UInt32Value) {
            self.cached_size.dirty();
            self.cold_mut().optional_uint32_wrapper = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_uint32_wrapper_mut(&mut self) -> &mut UInt32Value {
            self.cached_size.dirty();
            self.cold_mut().optional_uint32_wrapper.get_or_insert()
        }
        pub fn clear_optional_uint32_wrapper(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_uint32_wrapper.clear();
        }
        pub fn has_optional_uint64_wrapper(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_uint64_wrapper.is_some())
        }
        pub fn optional_uint64_wrapper(&self) -> &UInt64Value {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_uint64_wrapper.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_uint64_wrapper_opt(&self) -> Option<&UInt64Value> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_uint64_wrapper.as_deref())
        }
        pub fn optional_uint64_wrapper_view(&self) -> UInt64ValueView<'_> {
            UInt64ValueView(self.optional_uint64_wrapper())
        }
        pub fn set_optional_uint64_wrapper(&mut self, v: UInt64Value) {
            self.cached_size.dirty();
            self.cold_mut().optional_uint64_wrapper = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_uint64_wrapper_mut(&mut self) -> &mut UInt64Value {
            self.cached_size.dirty();
            self.cold_mut().optional_uint64_wrapper.get_or_insert()
        }
        pub fn clear_optional_uint64_wrapper(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_uint64_wrapper.clear();
        }
        pub fn has_optional_float_wrapper(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_float_wrapper.is_some())
        }
        pub fn optional_float_wrapper(&self) -> &FloatValue {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_float_wrapper.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_float_wrapper_opt(&self) -> Option<&FloatValue> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_float_wrapper.as_deref())
        }
        pub fn optional_float_wrapper_view(&self) -> FloatValueView<'_> {
            FloatValueView(self.optional_float_wrapper())
        }
        pub fn set_optional_float_wrapper(&mut self, v: FloatValue) {
            self.cached_size.dirty();
            self.cold_mut().optional_float_wrapper = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_float_wrapper_mut(&mut self) -> &mut FloatValue {
            self.cached_size.dirty();
            self.cold_mut().optional_float_wrapper.get_or_insert()
        }
        pub fn clear_optional_float_wrapper(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_float_wrapper.clear();
        }
        pub fn has_optional_double_wrapper(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_double_wrapper.is_some())
        }
        pub fn optional_double_wrapper(&self) -> &DoubleValue {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_double_wrapper.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_double_wrapper_opt(&self) -> Option<&DoubleValue> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_double_wrapper.as_deref())
        }
        pub fn optional_double_wrapper_view(&self) -> DoubleValueView<'_> {
            DoubleValueView(self.optional_double_wrapper())
        }
        pub fn set_optional_double_wrapper(&mut self, v: DoubleValue) {
            self.cached_size.dirty();
            self.cold_mut().optional_double_wrapper = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_double_wrapper_mut(&mut self) -> &mut DoubleValue {
            self.cached_size.dirty();
            self.cold_mut().optional_double_wrapper.get_or_insert()
        }
        pub fn clear_optional_double_wrapper(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_double_wrapper.clear();
        }
        pub fn has_optional_string_wrapper(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_string_wrapper.is_some())
        }
        pub fn optional_string_wrapper(&self) -> &StringValue {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_string_wrapper.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_string_wrapper_opt(&self) -> Option<&StringValue> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_string_wrapper.as_deref())
        }
        pub fn optional_string_wrapper_view(&self) -> StringValueView<'_> {
            StringValueView(self.optional_string_wrapper())
        }
        pub fn set_optional_string_wrapper(&mut self, v: StringValue) {
            self.cached_size.dirty();
            self.cold_mut().optional_string_wrapper = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_string_wrapper_mut(&mut self) -> &mut StringValue {
            self.cached_size.dirty();
            self.cold_mut().optional_string_wrapper.get_or_insert()
        }
        pub fn clear_optional_string_wrapper(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_string_wrapper.clear();
        }
        pub fn has_optional_bytes_wrapper(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_bytes_wrapper.is_some())
        }
        pub fn optional_bytes_wrapper(&self) -> &BytesValue {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_bytes_wrapper.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_bytes_wrapper_opt(&self) -> Option<&BytesValue> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_bytes_wrapper.as_deref())
        }
        pub fn optional_bytes_wrapper_view(&self) -> BytesValueView<'_> {
            BytesValueView(self.optional_bytes_wrapper())
        }
        pub fn set_optional_bytes_wrapper(&mut self, v: BytesValue) {
            self.cached_size.dirty();
            self.cold_mut().optional_bytes_wrapper = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_bytes_wrapper_mut(&mut self) -> &mut BytesValue {
            self.cached_size.dirty();
            self.cold_mut().optional_bytes_wrapper.get_or_insert()
        }
        pub fn clear_optional_bytes_wrapper(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_bytes_wrapper.clear();
        }
        pub fn repeated_bool_wrapper(&self) -> RepeatedView<'_, BoolValue> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_bool_wrapper.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_bool_wrapper_mut(&mut self) -> RepeatedMut<'_, BoolValue> {
            self.cached_size.dirty();
            self.cold_mut().repeated_bool_wrapper.as_mut()
        }
        pub fn set_repeated_bool_wrapper(&mut self, v: impl IntoIterator<Item = BoolValue>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_bool_wrapper = v.into_iter().collect();
        }
        pub fn repeated_int32_wrapper(&self) -> RepeatedView<'_, Int32Value> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_int32_wrapper.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_int32_wrapper_mut(&mut self) -> RepeatedMut<'_, Int32Value> {
            self.cached_size.dirty();
            self.cold_mut().repeated_int32_wrapper.as_mut()
        }
        pub fn set_repeated_int32_wrapper(&mut self, v: impl IntoIterator<Item = Int32Value>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_int32_wrapper = v.into_iter().collect();
        }
        pub fn repeated_int64_wrapper(&self) -> RepeatedView<'_, Int64Value> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_int64_wrapper.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_int64_wrapper_mut(&mut self) -> RepeatedMut<'_, Int64Value> {
            self.cached_size.dirty();
            self.cold_mut().repeated_int64_wrapper.as_mut()
        }
        pub fn set_repeated_int64_wrapper(&mut self, v: impl IntoIterator<Item = Int64Value>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_int64_wrapper = v.into_iter().collect();
        }
        pub fn repeated_uint32_wrapper(&self) -> RepeatedView<'_, UInt32Value> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_uint32_wrapper.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_uint32_wrapper_mut(&mut self) -> RepeatedMut<'_, UInt32Value> {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint32_wrapper.as_mut()
        }
        pub fn set_repeated_uint32_wrapper(&mut self, v: impl IntoIterator<Item = UInt32Value>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint32_wrapper = v.into_iter().collect();
        }
        pub fn repeated_uint64_wrapper(&self) -> RepeatedView<'_, UInt64Value> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_uint64_wrapper.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_uint64_wrapper_mut(&mut self) -> RepeatedMut<'_, UInt64Value> {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint64_wrapper.as_mut()
        }
        pub fn set_repeated_uint64_wrapper(&mut self, v: impl IntoIterator<Item = UInt64Value>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_uint64_wrapper = v.into_iter().collect();
        }
        pub fn repeated_float_wrapper(&self) -> RepeatedView<'_, FloatValue> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_float_wrapper.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_float_wrapper_mut(&mut self) -> RepeatedMut<'_, FloatValue> {
            self.cached_size.dirty();
            self.cold_mut().repeated_float_wrapper.as_mut()
        }
        pub fn set_repeated_float_wrapper(&mut self, v: impl IntoIterator<Item = FloatValue>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_float_wrapper = v.into_iter().collect();
        }
        pub fn repeated_double_wrapper(&self) -> RepeatedView<'_, DoubleValue> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_double_wrapper.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_double_wrapper_mut(&mut self) -> RepeatedMut<'_, DoubleValue> {
            self.cached_size.dirty();
            self.cold_mut().repeated_double_wrapper.as_mut()
        }
        pub fn set_repeated_double_wrapper(&mut self, v: impl IntoIterator<Item = DoubleValue>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_double_wrapper = v.into_iter().collect();
        }
        pub fn repeated_string_wrapper(&self) -> RepeatedView<'_, StringValue> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_string_wrapper.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_string_wrapper_mut(&mut self) -> RepeatedMut<'_, StringValue> {
            self.cached_size.dirty();
            self.cold_mut().repeated_string_wrapper.as_mut()
        }
        pub fn set_repeated_string_wrapper(&mut self, v: impl IntoIterator<Item = StringValue>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_string_wrapper = v.into_iter().collect();
        }
        pub fn repeated_bytes_wrapper(&self) -> RepeatedView<'_, BytesValue> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_bytes_wrapper.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_bytes_wrapper_mut(&mut self) -> RepeatedMut<'_, BytesValue> {
            self.cached_size.dirty();
            self.cold_mut().repeated_bytes_wrapper.as_mut()
        }
        pub fn set_repeated_bytes_wrapper(&mut self, v: impl IntoIterator<Item = BytesValue>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_bytes_wrapper = v.into_iter().collect();
        }
        pub fn has_optional_duration(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_duration.is_some())
        }
        pub fn optional_duration(&self) -> &Duration {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_duration.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_duration_opt(&self) -> Option<&Duration> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_duration.as_deref())
        }
        pub fn optional_duration_view(&self) -> DurationView<'_> {
            DurationView(self.optional_duration())
        }
        pub fn set_optional_duration(&mut self, v: Duration) {
            self.cached_size.dirty();
            self.cold_mut().optional_duration = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_duration_mut(&mut self) -> &mut Duration {
            self.cached_size.dirty();
            self.cold_mut().optional_duration.get_or_insert()
        }
        pub fn clear_optional_duration(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_duration.clear();
        }
        pub fn has_optional_timestamp(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_timestamp.is_some())
        }
        pub fn optional_timestamp(&self) -> &Timestamp {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_timestamp.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_timestamp_opt(&self) -> Option<&Timestamp> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_timestamp.as_deref())
        }
        pub fn optional_timestamp_view(&self) -> TimestampView<'_> {
            TimestampView(self.optional_timestamp())
        }
        pub fn set_optional_timestamp(&mut self, v: Timestamp) {
            self.cached_size.dirty();
            self.cold_mut().optional_timestamp = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_timestamp_mut(&mut self) -> &mut Timestamp {
            self.cached_size.dirty();
            self.cold_mut().optional_timestamp.get_or_insert()
        }
        pub fn clear_optional_timestamp(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_timestamp.clear();
        }
        pub fn has_optional_field_mask(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_field_mask.is_some())
        }
        pub fn optional_field_mask(&self) -> &FieldMask {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_field_mask.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_field_mask_opt(&self) -> Option<&FieldMask> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_field_mask.as_deref())
        }
        pub fn optional_field_mask_view(&self) -> FieldMaskView<'_> {
            FieldMaskView(self.optional_field_mask())
        }
        pub fn set_optional_field_mask(&mut self, v: FieldMask) {
            self.cached_size.dirty();
            self.cold_mut().optional_field_mask = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_field_mask_mut(&mut self) -> &mut FieldMask {
            self.cached_size.dirty();
            self.cold_mut().optional_field_mask.get_or_insert()
        }
        pub fn clear_optional_field_mask(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_field_mask.clear();
        }
        pub fn has_optional_struct(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_struct.is_some())
        }
        pub fn optional_struct(&self) -> &Struct {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_struct.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_struct_opt(&self) -> Option<&Struct> {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_struct.as_deref())
        }
        pub fn optional_struct_view(&self) -> StructView<'_> {
            StructView(self.optional_struct())
        }
        pub fn set_optional_struct(&mut self, v: Struct) {
            self.cached_size.dirty();
            self.cold_mut().optional_struct = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_struct_mut(&mut self) -> &mut Struct {
            self.cached_size.dirty();
            self.cold_mut().optional_struct.get_or_insert()
        }
        pub fn clear_optional_struct(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_struct.clear();
        }
        pub fn has_optional_any(&self) -> bool {
            self.cold.as_ref().is_some_and(|c| c.optional_any.is_some())
        }
        pub fn optional_any(&self) -> &Any {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_any.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_any_opt(&self) -> Option<&Any> {
            self.cold.as_ref().and_then(|c| c.optional_any.as_deref())
        }
        pub fn optional_any_view(&self) -> AnyView<'_> {
            AnyView(self.optional_any())
        }
        pub fn set_optional_any(&mut self, v: Any) {
            self.cached_size.dirty();
            self.cold_mut().optional_any = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_any_mut(&mut self) -> &mut Any {
            self.cached_size.dirty();
            self.cold_mut().optional_any.get_or_insert()
        }
        pub fn clear_optional_any(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_any.clear();
        }
        pub fn has_optional_value(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_value.is_some())
        }
        pub fn optional_value(&self) -> &PbValue {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_value.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_value_opt(&self) -> Option<&PbValue> {
            self.cold.as_ref().and_then(|c| c.optional_value.as_deref())
        }
        pub fn optional_value_view(&self) -> PbValueView<'_> {
            PbValueView(self.optional_value())
        }
        pub fn set_optional_value(&mut self, v: PbValue) {
            self.cached_size.dirty();
            self.cold_mut().optional_value = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_value_mut(&mut self) -> &mut PbValue {
            self.cached_size.dirty();
            self.cold_mut().optional_value.get_or_insert()
        }
        pub fn clear_optional_value(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_value.clear();
        }
        pub fn optional_null_value(&self) -> NullValue {
            NullValue(self.optional_null_value)
        }
        pub fn set_optional_null_value(&mut self, v: impl Into<i32>) {
            self.cached_size.dirty();
            self.optional_null_value = v.into();
        }
        pub fn has_optional_empty(&self) -> bool {
            self.cold
                .as_ref()
                .is_some_and(|c| c.optional_empty.is_some())
        }
        pub fn optional_empty(&self) -> &Empty {
            self.cold
                .as_ref()
                .and_then(|c| c.optional_empty.as_deref())
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn optional_empty_opt(&self) -> Option<&Empty> {
            self.cold.as_ref().and_then(|c| c.optional_empty.as_deref())
        }
        pub fn optional_empty_view(&self) -> EmptyView<'_> {
            EmptyView(self.optional_empty())
        }
        pub fn set_optional_empty(&mut self, v: Empty) {
            self.cached_size.dirty();
            self.cold_mut().optional_empty = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn optional_empty_mut(&mut self) -> &mut Empty {
            self.cached_size.dirty();
            self.cold_mut().optional_empty.get_or_insert()
        }
        pub fn clear_optional_empty(&mut self) {
            self.cached_size.dirty();
            self.cold_mut().optional_empty.clear();
        }
        pub fn repeated_duration(&self) -> RepeatedView<'_, Duration> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_duration.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_duration_mut(&mut self) -> RepeatedMut<'_, Duration> {
            self.cached_size.dirty();
            self.cold_mut().repeated_duration.as_mut()
        }
        pub fn set_repeated_duration(&mut self, v: impl IntoIterator<Item = Duration>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_duration = v.into_iter().collect();
        }
        pub fn repeated_timestamp(&self) -> RepeatedView<'_, Timestamp> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_timestamp.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_timestamp_mut(&mut self) -> RepeatedMut<'_, Timestamp> {
            self.cached_size.dirty();
            self.cold_mut().repeated_timestamp.as_mut()
        }
        pub fn set_repeated_timestamp(&mut self, v: impl IntoIterator<Item = Timestamp>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_timestamp = v.into_iter().collect();
        }
        pub fn repeated_fieldmask(&self) -> RepeatedView<'_, FieldMask> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_fieldmask.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_fieldmask_mut(&mut self) -> RepeatedMut<'_, FieldMask> {
            self.cached_size.dirty();
            self.cold_mut().repeated_fieldmask.as_mut()
        }
        pub fn set_repeated_fieldmask(&mut self, v: impl IntoIterator<Item = FieldMask>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_fieldmask = v.into_iter().collect();
        }
        pub fn repeated_any(&self) -> RepeatedView<'_, Any> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_any.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_any_mut(&mut self) -> RepeatedMut<'_, Any> {
            self.cached_size.dirty();
            self.cold_mut().repeated_any.as_mut()
        }
        pub fn set_repeated_any(&mut self, v: impl IntoIterator<Item = Any>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_any = v.into_iter().collect();
        }
        pub fn repeated_value(&self) -> RepeatedView<'_, PbValue> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_value.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_value_mut(&mut self) -> RepeatedMut<'_, PbValue> {
            self.cached_size.dirty();
            self.cold_mut().repeated_value.as_mut()
        }
        pub fn set_repeated_value(&mut self, v: impl IntoIterator<Item = PbValue>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_value = v.into_iter().collect();
        }
        pub fn repeated_list_value(&self) -> RepeatedView<'_, ListValue> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_list_value.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_list_value_mut(&mut self) -> RepeatedMut<'_, ListValue> {
            self.cached_size.dirty();
            self.cold_mut().repeated_list_value.as_mut()
        }
        pub fn set_repeated_list_value(&mut self, v: impl IntoIterator<Item = ListValue>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_list_value = v.into_iter().collect();
        }
        pub fn repeated_empty(&self) -> RepeatedView<'_, Empty> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_empty.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_empty_mut(&mut self) -> RepeatedMut<'_, Empty> {
            self.cached_size.dirty();
            self.cold_mut().repeated_empty.as_mut()
        }
        pub fn set_repeated_empty(&mut self, v: impl IntoIterator<Item = Empty>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_empty = v.into_iter().collect();
        }
        pub fn repeated_struct(&self) -> RepeatedView<'_, Struct> {
            self.cold
                .as_ref()
                .map(|c| c.repeated_struct.as_view())
                .unwrap_or_else(|| RepeatedView::from_slice(&[]))
        }
        pub fn repeated_struct_mut(&mut self) -> RepeatedMut<'_, Struct> {
            self.cached_size.dirty();
            self.cold_mut().repeated_struct.as_mut()
        }
        pub fn set_repeated_struct(&mut self, v: impl IntoIterator<Item = Struct>) {
            self.cached_size.dirty();
            self.cold_mut().repeated_struct = v.into_iter().collect();
        }
        pub fn fieldname1(&self) -> i32 {
            self.fieldname1
        }
        pub fn set_fieldname1(&mut self, v: i32) {
            self.cached_size.dirty();
            self.fieldname1 = v;
        }
        pub fn field_name2(&self) -> i32 {
            self.field_name2
        }
        pub fn set_field_name2(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field_name2 = v;
        }
        pub fn _field_name3(&self) -> i32 {
            self._field_name3
        }
        pub fn set__field_name3(&mut self, v: i32) {
            self.cached_size.dirty();
            self._field_name3 = v;
        }
        pub fn field__name4_(&self) -> i32 {
            self.field__name4_
        }
        pub fn set_field__name4_(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field__name4_ = v;
        }
        pub fn field0name5(&self) -> i32 {
            self.field0name5
        }
        pub fn set_field0name5(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field0name5 = v;
        }
        pub fn field_0_name6(&self) -> i32 {
            self.field_0_name6
        }
        pub fn set_field_0_name6(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field_0_name6 = v;
        }
        pub fn fieldName7(&self) -> i32 {
            self.fieldName7
        }
        pub fn set_fieldName7(&mut self, v: i32) {
            self.cached_size.dirty();
            self.fieldName7 = v;
        }
        pub fn FieldName8(&self) -> i32 {
            self.FieldName8
        }
        pub fn set_FieldName8(&mut self, v: i32) {
            self.cached_size.dirty();
            self.FieldName8 = v;
        }
        pub fn field_Name9(&self) -> i32 {
            self.field_Name9
        }
        pub fn set_field_Name9(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field_Name9 = v;
        }
        pub fn Field_Name10(&self) -> i32 {
            self.Field_Name10
        }
        pub fn set_Field_Name10(&mut self, v: i32) {
            self.cached_size.dirty();
            self.Field_Name10 = v;
        }
        pub fn FIELD_NAME11(&self) -> i32 {
            self.FIELD_NAME11
        }
        pub fn set_FIELD_NAME11(&mut self, v: i32) {
            self.cached_size.dirty();
            self.FIELD_NAME11 = v;
        }
        pub fn FIELD_name12(&self) -> i32 {
            self.FIELD_name12
        }
        pub fn set_FIELD_name12(&mut self, v: i32) {
            self.cached_size.dirty();
            self.FIELD_name12 = v;
        }
        pub fn __field_name13(&self) -> i32 {
            self.__field_name13
        }
        pub fn set___field_name13(&mut self, v: i32) {
            self.cached_size.dirty();
            self.__field_name13 = v;
        }
        pub fn __Field_name14(&self) -> i32 {
            self.__Field_name14
        }
        pub fn set___Field_name14(&mut self, v: i32) {
            self.cached_size.dirty();
            self.__Field_name14 = v;
        }
        pub fn field__name15(&self) -> i32 {
            self.field__name15
        }
        pub fn set_field__name15(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field__name15 = v;
        }
        pub fn field__Name16(&self) -> i32 {
            self.field__Name16
        }
        pub fn set_field__Name16(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field__Name16 = v;
        }
        pub fn field_name17__(&self) -> i32 {
            self.field_name17__
        }
        pub fn set_field_name17__(&mut self, v: i32) {
            self.cached_size.dirty();
            self.field_name17__ = v;
        }
        pub fn Field_name18__(&self) -> i32 {
            self.Field_name18__
        }
        pub fn set_Field_name18__(&mut self, v: i32) {
            self.cached_size.dirty();
            self.Field_name18__ = v;
        }
        #[inline(always)]
        fn check_required(&self) -> Result<(), ParseError> {
            Ok(())
        }
        fn merge_bytes(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return self.check_required();
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, true, None)
        }
        fn merge_bytes_dont_enforce(&mut self, data: &[u8], depth: u32) -> Result<(), ParseError> {
            if data.is_empty() {
                return Ok(());
            }
            let mut pos = 0;
            let mut wire = None;
            self.merge_inner(data, &mut wire, &mut pos, depth, false, None)
        }
        fn merge_group(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            num: u32,
            depth: u32,
        ) -> Result<(), ParseError> {
            self.merge_inner(data, wire, pos, depth, false, Some(num))
        }
        fn merge_inner(
            &mut self,
            data: &[u8],
            wire: &mut Option<pbrs::rt::Wire>,
            pos: &mut usize,
            depth: u32,
            enforce: bool,
            until: Option<u32>,
        ) -> Result<(), ParseError> {
            if depth > pbrs::RECURSION_LIMIT {
                return Err(ParseError::new("recursion limit exceeded"));
            }
            let _ = enforce;
            self.cached_size.dirty();
            while *pos < data.len() {
                let (n, w) = pbrs::rt::decode_tag(data, pos)?;
                if let Some(g) = until {
                    if w == pbrs::rt::WIRE_EGROUP {
                        if n != g {
                            return Err(ParseError::new("mismatched end-group"));
                        }
                        return Ok(());
                    }
                }
                match n {
                    1 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_int32 = 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 = 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 = 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 = 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 =
                                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 =
                                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 = 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 = 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 = 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 = 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 =
                                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 =
                                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::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)?;
                            self.optional_string =
                                pbrs::rt::LazyStr::from_parse_span(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 = pbrs::rt::LazyBytes::from_parse_span(wire, data, s, e);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    18 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.optional_nested_message.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.optional_nested_message.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                NestedMessage::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.optional_nested_message = pbrs::rt::LazyMsg::from_wire(
                                    pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                );
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    19 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.optional_foreign_message.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.optional_foreign_message.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                ForeignMessage::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 = 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 = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    23 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_aliased_enum = 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)?;
                            self.optional_string_piece =
                                pbrs::rt::LazyStr::from_parse_span(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)?;
                            self.optional_cord =
                                pbrs::rt::LazyStr::from_parse_span(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;
                                TestAllTypesProto3::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.recursive_message = pbrs::rt::LazyMsg::from_wire(
                                    pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                );
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    31 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_int32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_int32
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_int32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 31 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_int32
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    32 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_int64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_int64
                                .push(pbrs::rt::decode_varint(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_int64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 32 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_int64
                                        .push(pbrs::rt::decode_varint(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    33 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_uint32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_uint32
                                .push(pbrs::rt::decode_varint(data, pos)? as u32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_uint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 33 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_uint32
                                        .push(pbrs::rt::decode_varint(data, pos)? as u32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    34 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_uint64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_uint64
                                .push(pbrs::rt::decode_varint(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_uint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 34 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_uint64
                                        .push(pbrs::rt::decode_varint(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    35 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_sint32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_sint32
                                .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_sint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 35 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_sint32
                                        .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    36 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_sint64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_sint64
                                .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_sint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 36 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_sint64
                                        .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    37 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_fixed32
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .repeated_fixed32
                                .push(pbrs::rt::read_fixed32(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_fixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 37 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .repeated_fixed32
                                        .push(pbrs::rt::read_fixed32(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    38 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_fixed64
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .repeated_fixed64
                                .push(pbrs::rt::read_fixed64(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_fixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 38 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .repeated_fixed64
                                        .push(pbrs::rt::read_fixed64(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    39 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_sfixed32
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .repeated_sfixed32
                                .push(pbrs::rt::read_fixed32(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_sfixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 39 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .repeated_sfixed32
                                        .push(pbrs::rt::read_fixed32(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    40 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_sfixed64
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .repeated_sfixed64
                                .push(pbrs::rt::read_fixed64(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_sfixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 40 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .repeated_sfixed64
                                        .push(pbrs::rt::read_fixed64(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    41 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_float
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .repeated_float
                                .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_float.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 41 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .repeated_float
                                        .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    42 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_double
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .repeated_double
                                .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_double.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 42 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .repeated_double
                                        .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    43 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_bool
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_bool
                                .push(pbrs::rt::decode_varint(data, pos)? != 0);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_bool.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 43 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_bool
                                        .push(pbrs::rt::decode_varint(data, pos)? != 0),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    44 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let rest = data.len().saturating_sub(e);
                            if rest > 2 {
                                self.repeated_string.reserve(1 + rest / (e - s + 2).max(1));
                            }
                            self.repeated_string
                                .push(pbrs::rt::LazyStr::from_parse_span(wire, data, s, e)?);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 44 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        self.repeated_string.push(
                                            pbrs::rt::LazyStr::from_parse_span(wire, data, s, e)?,
                                        );
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    45 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.repeated_bytes.push(pbrs::rt::LazyBytes::from_parse_span(wire, data, s, e));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    48 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let rest = data.len().saturating_sub(e);
                            if rest > 2 {
                                self.repeated_nested_message
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = NestedMessage::default();
                            let mut ip = 0;
                            let mut sw = None;
                            inner.merge_inner(
                                &data[s..e],
                                &mut sw,
                                &mut ip,
                                depth + 1,
                                true,
                                None,
                            )?;
                            self.repeated_nested_message.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 48 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = NestedMessage::default();
                                        let mut ip = 0;
                                        let mut sw = None;
                                        inner.merge_inner(
                                            &data[s..e],
                                            &mut sw,
                                            &mut ip,
                                            depth + 1,
                                            true,
                                            None,
                                        )?;
                                        self.repeated_nested_message.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    49 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let rest = data.len().saturating_sub(e);
                            if rest > 2 {
                                self.cold_mut()
                                    .repeated_foreign_message
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = ForeignMessage::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 = ForeignMessage::default();
                                        let mut ip = 0;
                                        let mut sw = None;
                                        inner.merge_inner(
                                            &data[s..e],
                                            &mut sw,
                                            &mut ip,
                                            depth + 1,
                                            true,
                                            None,
                                        )?;
                                        self.cold_mut().repeated_foreign_message.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    51 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_nested_enum
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_nested_enum
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_nested_enum.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 51 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_nested_enum
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    52 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .repeated_foreign_enum
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .repeated_foreign_enum
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().repeated_foreign_enum.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 52 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .repeated_foreign_enum
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    54 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.repeated_string_piece
                                .push(pbrs::rt::LazyStr::from_span(
                                    pbrs::rt::Wire::ensure(wire, data),
                                    s,
                                    e,
                                ));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    55 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.repeated_cord.push(pbrs::rt::LazyStr::from_span(
                                pbrs::rt::Wire::ensure(wire, data),
                                s,
                                e,
                            ));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    56 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let (kk, vv) = decode_map_entry_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_map_string_foreign_enum_74(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    depth + 1,
                                )?;
                            self.map_string_foreign_enum.push_entry(kk, vv);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    75 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_int32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_int32
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_int32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 75 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_int32
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    76 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_int64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_int64
                                .push(pbrs::rt::decode_varint(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_int64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 76 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_int64
                                        .push(pbrs::rt::decode_varint(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    77 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_uint32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_uint32
                                .push(pbrs::rt::decode_varint(data, pos)? as u32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_uint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 77 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_uint32
                                        .push(pbrs::rt::decode_varint(data, pos)? as u32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    78 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_uint64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_uint64
                                .push(pbrs::rt::decode_varint(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_uint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 78 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_uint64
                                        .push(pbrs::rt::decode_varint(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    79 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_sint32
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_sint32
                                .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_sint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 79 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_sint32
                                        .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    80 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_sint64
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_sint64
                                .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_sint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 80 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_sint64
                                        .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    81 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.packed_fixed32
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.packed_fixed32.push(pbrs::rt::read_fixed32(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.packed_fixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 81 && w2 == pbrs::rt::WIRE_I32 => {
                                        self.packed_fixed32.push(pbrs::rt::read_fixed32(data, pos)?)
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    82 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.packed_fixed64
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.packed_fixed64.push(pbrs::rt::read_fixed64(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.packed_fixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 82 && w2 == pbrs::rt::WIRE_I64 => {
                                        self.packed_fixed64.push(pbrs::rt::read_fixed64(data, pos)?)
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    83 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_sfixed32
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .packed_sfixed32
                                .push(pbrs::rt::read_fixed32(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_sfixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 83 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .packed_sfixed32
                                        .push(pbrs::rt::read_fixed32(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    84 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_sfixed64
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .packed_sfixed64
                                .push(pbrs::rt::read_fixed64(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_sfixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 84 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .packed_sfixed64
                                        .push(pbrs::rt::read_fixed64(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    85 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.packed_float
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.packed_float
                                .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.packed_float.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 85 && w2 == pbrs::rt::WIRE_I32 => self
                                        .packed_float
                                        .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    86 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_double
                                .append_wire(pbrs::rt::Wire::from_slice(&data[s..e]))?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .packed_double
                                .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_double.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 86 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .packed_double
                                        .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    87 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_bool
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_bool
                                .push(pbrs::rt::decode_varint(data, pos)? != 0);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_bool.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 87 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_bool
                                        .push(pbrs::rt::decode_varint(data, pos)? != 0),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    88 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.cold_mut()
                                .packed_nested_enum
                                .append_wire(pbrs::rt::Wire::ensure(wire, data).window(s, e))?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .packed_nested_enum
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().packed_nested_enum.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 88 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .packed_nested_enum
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    89 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_int32
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as i32);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_int32
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_int32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 89 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_int32
                                        .push(pbrs::rt::decode_varint(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    90 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_int64
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as i64);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_int64
                                .push(pbrs::rt::decode_varint(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_int64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 90 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_int64
                                        .push(pbrs::rt::decode_varint(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    91 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_uint32
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as u32);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_uint32
                                .push(pbrs::rt::decode_varint(data, pos)? as u32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_uint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 91 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_uint32
                                        .push(pbrs::rt::decode_varint(data, pos)? as u32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    92 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_uint64
                                    .push(pbrs::rt::decode_varint(p, &mut i)?);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_uint64
                                .push(pbrs::rt::decode_varint(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_uint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 92 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_uint64
                                        .push(pbrs::rt::decode_varint(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    93 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_sint32
                                    .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                        p, &mut i,
                                    )?));
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_sint32
                                .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_sint32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 93 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_sint32
                                        .push(pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    94 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_sint64
                                    .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                        p, &mut i,
                                    )?));
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_sint64
                                .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                    data, pos,
                                )?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_sint64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 94 && w2 == pbrs::rt::WIRE_VARINT => self
                                        .cold_mut()
                                        .unpacked_sint64
                                        .push(pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(
                                            data, pos,
                                        )?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    95 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_fixed32
                                    .push(pbrs::rt::read_fixed32(p, &mut i)?);
                            }
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .unpacked_fixed32
                                .push(pbrs::rt::read_fixed32(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_fixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 95 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .unpacked_fixed32
                                        .push(pbrs::rt::read_fixed32(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    96 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_fixed64
                                    .push(pbrs::rt::read_fixed64(p, &mut i)?);
                            }
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .unpacked_fixed64
                                .push(pbrs::rt::read_fixed64(data, pos)?);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_fixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 96 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .unpacked_fixed64
                                        .push(pbrs::rt::read_fixed64(data, pos)?),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    97 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_sfixed32
                                    .push(pbrs::rt::read_fixed32(p, &mut i)? as i32);
                            }
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .unpacked_sfixed32
                                .push(pbrs::rt::read_fixed32(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_sfixed32.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 97 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .unpacked_sfixed32
                                        .push(pbrs::rt::read_fixed32(data, pos)? as i32),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    98 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_sfixed64
                                    .push(pbrs::rt::read_fixed64(p, &mut i)? as i64);
                            }
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .unpacked_sfixed64
                                .push(pbrs::rt::read_fixed64(data, pos)? as i64);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_sfixed64.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 98 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .unpacked_sfixed64
                                        .push(pbrs::rt::read_fixed64(data, pos)? as i64),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    99 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_float
                                    .push(f32::from_bits(pbrs::rt::read_fixed32(p, &mut i)?));
                            }
                        }
                        pbrs::rt::WIRE_I32 => {
                            self.cold_mut()
                                .unpacked_float
                                .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_float.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 99 && w2 == pbrs::rt::WIRE_I32 => self
                                        .cold_mut()
                                        .unpacked_float
                                        .push(f32::from_bits(pbrs::rt::read_fixed32(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    100 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_double
                                    .push(f64::from_bits(pbrs::rt::read_fixed64(p, &mut i)?));
                            }
                        }
                        pbrs::rt::WIRE_I64 => {
                            self.cold_mut()
                                .unpacked_double
                                .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?));
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_double.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 100 && w2 == pbrs::rt::WIRE_I64 => self
                                        .cold_mut()
                                        .unpacked_double
                                        .push(f64::from_bits(pbrs::rt::read_fixed64(data, pos)?)),
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    101 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_bool
                                    .push(pbrs::rt::decode_varint(p, &mut i)? != 0);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_bool
                                .push(pbrs::rt::decode_varint(data, pos)? != 0);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_bool.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 101 && w2 == pbrs::rt::WIRE_VARINT => {
                                        self.cold_mut()
                                            .unpacked_bool
                                            .push(pbrs::rt::decode_varint(data, pos)? != 0)
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    102 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let p = pbrs::rt::read_len_bytes(data, pos)?;
                            let mut i = 0;
                            while i < p.len() {
                                self.cold_mut()
                                    .unpacked_nested_enum
                                    .push(pbrs::rt::decode_varint(p, &mut i)? as i32);
                            }
                        }
                        pbrs::rt::WIRE_VARINT => {
                            self.cold_mut()
                                .unpacked_nested_enum
                                .push(pbrs::rt::decode_varint(data, pos)? as i32);
                            let rest = data.len().saturating_sub(*pos);
                            if rest > 2 {
                                self.cold_mut().unpacked_nested_enum.reserve(rest / 3);
                            }
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 102 && w2 == pbrs::rt::WIRE_VARINT => {
                                        self.cold_mut()
                                            .unpacked_nested_enum
                                            .push(pbrs::rt::decode_varint(data, pos)? as i32)
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    111 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.oneof_nested_message = Default::default();
                            self.oneof_string = None;
                            self.oneof_bytes = None;
                            self.oneof_bool = pbrs::rt::OptBool::NONE;
                            self.oneof_uint64 = None;
                            self.oneof_float = None;
                            self.oneof_double = None;
                            self.oneof_enum = None;
                            self.oneof_null_value = 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;
                            self.oneof_null_value = None;
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.oneof_nested_message.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.oneof_nested_message.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                NestedMessage::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.oneof_nested_message = pbrs::rt::LazyMsg::from_wire(
                                    pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                );
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    113 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.oneof_uint32 = None;
                            self.oneof_nested_message = Default::default();
                            self.oneof_bytes = None;
                            self.oneof_bool = pbrs::rt::OptBool::NONE;
                            self.oneof_uint64 = None;
                            self.oneof_float = None;
                            self.oneof_double = None;
                            self.oneof_enum = None;
                            self.oneof_null_value = None;
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let b = &data[s..e];
                            std::str::from_utf8(b).map_err(|_| ParseError::new("invalid utf-8"))?;
                            self.oneof_string = Some(Box::new(pbrs::rt::LazyStr::from_span(
                                pbrs::rt::Wire::ensure(wire, data),
                                s,
                                e,
                            )));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    114 => match w {
                        pbrs::rt::WIRE_LEN => {
                            self.oneof_uint32 = None;
                            self.oneof_nested_message = Default::default();
                            self.oneof_string = None;
                            self.oneof_bool = pbrs::rt::OptBool::NONE;
                            self.oneof_uint64 = None;
                            self.oneof_float = None;
                            self.oneof_double = None;
                            self.oneof_enum = None;
                            self.oneof_null_value = None;
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            self.oneof_bytes = Some(Box::new(pbrs::rt::LazyBytes::from_parse_span(wire, data, s, e)));
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    115 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.oneof_uint32 = None;
                            self.oneof_nested_message = Default::default();
                            self.oneof_string = None;
                            self.oneof_bytes = None;
                            self.oneof_uint64 = None;
                            self.oneof_float = None;
                            self.oneof_double = None;
                            self.oneof_enum = None;
                            self.oneof_null_value = 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_null_value = 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_null_value = 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_null_value = 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_null_value = 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.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 = None;
                            self.oneof_null_value =
                                Some(pbrs::rt::decode_varint(data, pos)? as i32);
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    201 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_bool_wrapper.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_bool_wrapper
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                BoolValue::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_bool_wrapper =
                                    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)?),
                    },
                    202 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_int32_wrapper.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_int32_wrapper
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                Int32Value::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_int32_wrapper =
                                    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)?),
                    },
                    203 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_int64_wrapper.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_int64_wrapper
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                Int64Value::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_int64_wrapper =
                                    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)?),
                    },
                    204 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_uint32_wrapper.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_uint32_wrapper
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                UInt32Value::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_uint32_wrapper =
                                    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)?),
                    },
                    205 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_uint64_wrapper.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_uint64_wrapper
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                UInt64Value::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_uint64_wrapper =
                                    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)?),
                    },
                    206 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_float_wrapper.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_float_wrapper
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                FloatValue::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_float_wrapper =
                                    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)?),
                    },
                    207 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_double_wrapper.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_double_wrapper
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                DoubleValue::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_double_wrapper =
                                    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)?),
                    },
                    208 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_string_wrapper.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_string_wrapper
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                StringValue::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_string_wrapper =
                                    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)?),
                    },
                    209 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_bytes_wrapper.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_bytes_wrapper
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                BytesValue::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_bytes_wrapper =
                                    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)?),
                    },
                    211 => 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_bool_wrapper
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = BoolValue::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_bool_wrapper.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 211 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = BoolValue::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_bool_wrapper.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    212 => 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_int32_wrapper
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = Int32Value::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_int32_wrapper.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 212 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = Int32Value::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_int32_wrapper.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    213 => 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_int64_wrapper
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = Int64Value::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_int64_wrapper.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 213 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = Int64Value::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_int64_wrapper.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    214 => 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_uint32_wrapper
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = UInt32Value::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_uint32_wrapper.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 214 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = UInt32Value::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_uint32_wrapper.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    215 => 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_uint64_wrapper
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = UInt64Value::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_uint64_wrapper.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 215 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = UInt64Value::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_uint64_wrapper.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    216 => 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_float_wrapper
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = FloatValue::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_float_wrapper.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 216 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = FloatValue::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_float_wrapper.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    217 => 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_double_wrapper
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = DoubleValue::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_double_wrapper.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 217 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = DoubleValue::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_double_wrapper.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    218 => 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_string_wrapper
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = StringValue::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_string_wrapper.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 218 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = StringValue::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_string_wrapper.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    219 => 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_bytes_wrapper
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = BytesValue::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_bytes_wrapper.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 219 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = BytesValue::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_bytes_wrapper.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    301 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_duration.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_duration
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                Duration::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_duration = 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)?),
                    },
                    302 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_timestamp.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_timestamp
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                Timestamp::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_timestamp = 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)?),
                    },
                    303 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_field_mask.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_field_mask
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                FieldMask::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_field_mask = 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)?),
                    },
                    304 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_struct.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut()
                                    .optional_struct
                                    .get_or_insert()
                                    .merge_inner(
                                        &data[s..e],
                                        &mut sw,
                                        &mut ip,
                                        depth + 1,
                                        true,
                                        None,
                                    )?;
                            } else {
                                let mut ip = 0;
                                Struct::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_struct = 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)?),
                    },
                    305 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_any.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut().optional_any.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                Any::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_any = 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)?),
                    },
                    306 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_value.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut().optional_value.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                PbValue::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_value = 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)?),
                    },
                    307 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.optional_null_value = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    308 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            if self.cold_mut().optional_empty.is_some() {
                                let mut ip = 0;
                                let mut sw = None;
                                self.cold_mut().optional_empty.get_or_insert().merge_inner(
                                    &data[s..e],
                                    &mut sw,
                                    &mut ip,
                                    depth + 1,
                                    true,
                                    None,
                                )?;
                            } else {
                                let mut ip = 0;
                                Empty::validate_inner(
                                    &pbrs::rt::Wire::ensure(wire, data).window(s, e),
                                    &mut ip,
                                    depth + 1,
                                )?;
                                self.cold_mut().optional_empty = 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)?),
                    },
                    311 => 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_duration
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = Duration::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_duration.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 311 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = Duration::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_duration.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    312 => 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_timestamp
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = Timestamp::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_timestamp.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 312 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = Timestamp::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_timestamp.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    313 => 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_fieldmask
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = FieldMask::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_fieldmask.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 313 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = FieldMask::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_fieldmask.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    315 => 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_any
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = Any::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_any.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 315 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = Any::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_any.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    316 => 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_value
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = PbValue::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_value.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 316 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = PbValue::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_value.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    317 => 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_list_value
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = ListValue::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_list_value.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 317 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = ListValue::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_list_value.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    318 => 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_empty
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = Empty::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_empty.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 318 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = Empty::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_empty.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    324 => 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_struct
                                    .reserve(1 + rest / (e - s + 4).max(1));
                            }
                            let mut inner = Struct::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_struct.push(inner);
                            while *pos < data.len() {
                                let save = *pos;
                                match pbrs::rt::decode_tag(data, pos) {
                                    Ok((n2, w2)) if n2 == 324 && w2 == pbrs::rt::WIRE_LEN => {
                                        let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                                        let mut inner = Struct::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_struct.push(inner);
                                    }
                                    Ok(_) => {
                                        *pos = save;
                                        break;
                                    }
                                    Err(e) => return Err(e),
                                }
                            }
                        }
                        _ => self
                            .unknown
                            .fields
                            .push(pbrs::rt::capture_unknown(data, pos, n, w)?),
                    },
                    401 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            self.fieldname1 = 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 = 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 = 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_ = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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__ = 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__ = 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 i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    3 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    4 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    5 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    6 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    7 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    8 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    9 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    10 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    11 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    12 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    13 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    14 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    15 => match w {
                        pbrs::rt::WIRE_LEN => {
                            pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    18 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            NestedMessage::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    19 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            ForeignMessage::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)?,
                    },
                    23 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    24 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    25 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    27 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            TestAllTypesProto3::validate_inner(
                                &wire.window(s, e),
                                &mut ip,
                                depth + 1,
                            )?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    31 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    32 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    33 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    34 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    35 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    36 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    37 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    38 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    39 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    40 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    41 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    42 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    43 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedBool::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    44 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    45 => match w {
                        pbrs::rt::WIRE_LEN => {
                            pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    48 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            NestedMessage::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    49 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            ForeignMessage::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    51 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    52 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    54 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    55 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    56 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    57 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    58 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    59 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    60 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    61 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    62 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    63 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    64 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    65 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    66 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    67 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    68 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    69 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    70 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    71 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    72 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    73 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    74 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            let w = wire.window(s, e);
                            let d = w.as_slice();
                            while ip < d.len() {
                                let (_, ww) = pbrs::rt::decode_tag(d, &mut ip)?;
                                pbrs::rt::skip_field(d, &mut ip, ww)?;
                            }
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    75 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    76 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    77 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    78 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    79 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    80 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    81 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    82 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    83 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    84 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    85 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    86 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    87 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedBool::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    88 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    89 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    90 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    91 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    92 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedU64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    93 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag32(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    94 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedS64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_zigzag64(pbrs::rt::decode_varint(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    95 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    96 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedFx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    97 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = pbrs::rt::read_fixed32(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    98 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedSfx64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = pbrs::rt::read_fixed64(data, pos)? as i64;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    99 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    100 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedF64::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    101 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedBool::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    102 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            pbrs::rt::PackedI32::validate_bytes(&data[s..e])?;
                        }
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    111 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as u32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    112 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            NestedMessage::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    113 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            std::str::from_utf8(&data[s..e])
                                .map_err(|_| ParseError::new("invalid utf-8"))?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    114 => match w {
                        pbrs::rt::WIRE_LEN => {
                            pbrs::rt::read_len_span(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    115 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? != 0;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    116 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    117 => match w {
                        pbrs::rt::WIRE_I32 => {
                            let _ = f32::from_bits(pbrs::rt::read_fixed32(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    118 => match w {
                        pbrs::rt::WIRE_I64 => {
                            let _ = f64::from_bits(pbrs::rt::read_fixed64(data, pos)?);
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    119 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    120 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    201 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            BoolValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    202 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Int32Value::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    203 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Int64Value::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    204 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            UInt32Value::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    205 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            UInt64Value::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    206 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            FloatValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    207 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            DoubleValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    208 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            StringValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    209 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            BytesValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    211 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            BoolValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    212 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Int32Value::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    213 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Int64Value::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    214 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            UInt32Value::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    215 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            UInt64Value::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    216 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            FloatValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    217 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            DoubleValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    218 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            StringValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    219 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            BytesValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    301 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Duration::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    302 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Timestamp::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    303 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            FieldMask::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    304 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Struct::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    305 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Any::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    306 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            PbValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    307 => match w {
                        pbrs::rt::WIRE_VARINT => {
                            let _ = pbrs::rt::decode_varint(data, pos)? as i32;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    308 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Empty::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    311 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Duration::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    312 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Timestamp::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    313 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            FieldMask::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    315 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Any::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    316 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            PbValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    317 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            ListValue::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    318 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Empty::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => pbrs::rt::skip_field(data, pos, w)?,
                    },
                    324 => match w {
                        pbrs::rt::WIRE_LEN => {
                            let (s, e) = pbrs::rt::read_len_span(data, pos)?;
                            let mut ip = 0;
                            Struct::validate_inner(&wire.window(s, e), &mut ip, depth + 1)?;
                        }
                        _ => 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)?,
                    },
                    _ => 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 self.optional_int32 != 0 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.optional_int32) as u64);
            }
            if self.optional_int64 != 0 {
                n += pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.optional_int64) as u64);
            }
            if self.optional_uint32 != 0 {
                n += pbrs::rt::tag_len(3, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.optional_uint32) as u64);
            }
            if self.optional_uint64 != 0 {
                n += pbrs::rt::tag_len(4, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.optional_uint64) as u64);
            }
            if self.optional_sint32 != 0 {
                n += pbrs::rt::tag_len(5, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(self.optional_sint32));
            }
            if self.optional_sint64 != 0 {
                n += pbrs::rt::tag_len(6, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(self.optional_sint64));
            }
            if self.optional_fixed32 != 0 {
                n += pbrs::rt::tag_len(7, pbrs::rt::WIRE_I32) + 4;
            }
            if self.optional_fixed64 != 0 {
                n += pbrs::rt::tag_len(8, pbrs::rt::WIRE_I64) + 8;
            }
            if self.optional_sfixed32 != 0 {
                n += pbrs::rt::tag_len(9, pbrs::rt::WIRE_I32) + 4;
            }
            if self.optional_sfixed64 != 0 {
                n += pbrs::rt::tag_len(10, pbrs::rt::WIRE_I64) + 8;
            }
            if self.optional_float.to_bits() != 0 {
                n += pbrs::rt::tag_len(11, pbrs::rt::WIRE_I32) + 4;
            }
            if self.optional_double.to_bits() != 0 {
                n += pbrs::rt::tag_len(12, pbrs::rt::WIRE_I64) + 8;
            }
            if self.optional_bool {
                n += pbrs::rt::tag_len(13, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(u64::from(self.optional_bool));
            }
            if !self.optional_string.is_empty() {
                n += pbrs::rt::key_len_value_len(14, self.optional_string.as_bytes().len() as u64);
            }
            if !self.optional_bytes.is_empty() {
                n += pbrs::rt::key_len_value_len(15, self.optional_bytes.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 self.optional_nested_enum != 0 {
                n += pbrs::rt::tag_len(21, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.optional_nested_enum) as u64);
            }
            if self.optional_foreign_enum != 0 {
                n += pbrs::rt::tag_len(22, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.optional_foreign_enum) as u64);
            }
            if self.optional_aliased_enum != 0 {
                n += pbrs::rt::tag_len(23, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.optional_aliased_enum) as u64);
            }
            if !self.optional_string_piece.is_empty() {
                n += pbrs::rt::key_len_value_len(
                    24,
                    self.optional_string_piece.as_bytes().len() as u64,
                );
            }
            if !self.optional_cord.is_empty() {
                n += pbrs::rt::key_len_value_len(25, self.optional_cord.as_bytes().len() as u64);
            }
            if let Some(p) = self.recursive_message.wire_bytes() {
                n += pbrs::rt::key_len_value_len(27, p.len() as u64);
            } else if let Some(m) = self.recursive_message.as_deref() {
                n += pbrs::rt::key_len_value_len(27, m.compute_size());
            }
            for t in self.repeated_string.iter() {
                n += pbrs::rt::key_len_value_len(44, t.as_bytes().len() as u64);
            }
            for t in self.repeated_bytes.iter() {
                n += pbrs::rt::key_len_value_len(45, t.as_bytes().len() as u64);
            }
            for t in self.repeated_nested_message.iter() {
                n += pbrs::rt::key_len_value_len(48, t.compute_size());
            }
            for t in self.repeated_string_piece.iter() {
                n += pbrs::rt::key_len_value_len(54, t.as_bytes().len() as u64);
            }
            for t in self.repeated_cord.iter() {
                n += pbrs::rt::key_len_value_len(55, t.as_bytes().len() as u64);
            }
            if !self.map_int32_int32.is_empty() {
                for (k, v) in self.map_int32_int32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    n += pbrs::rt::key_len_value_len(56, inner);
                }
            }
            if !self.map_int64_int64.is_empty() {
                for (k, v) in self.map_int64_int64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    n += pbrs::rt::key_len_value_len(57, inner);
                }
            }
            if !self.map_uint32_uint32.is_empty() {
                for (k, v) in self.map_uint32_uint32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*v));
                    n += pbrs::rt::key_len_value_len(58, inner);
                }
            }
            if !self.map_uint64_uint64.is_empty() {
                for (k, v) in self.map_uint64_uint64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(*k)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(*v);
                    n += pbrs::rt::key_len_value_len(59, inner);
                }
            }
            if !self.map_sint32_sint32.is_empty() {
                for (k, v) in self.map_sint32_sint32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*v));
                    n += pbrs::rt::key_len_value_len(60, inner);
                }
            }
            if !self.map_sint64_sint64.is_empty() {
                for (k, v) in self.map_sint64_sint64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*v));
                    n += pbrs::rt::key_len_value_len(61, inner);
                }
            }
            if !self.map_fixed32_fixed32.is_empty() {
                for (k, v) in self.map_fixed32_fixed32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32)
                        + 4
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    n += pbrs::rt::key_len_value_len(62, inner);
                }
            }
            if !self.map_fixed64_fixed64.is_empty() {
                for (k, v) in self.map_fixed64_fixed64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I64)
                        + 8
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    n += pbrs::rt::key_len_value_len(63, inner);
                }
            }
            if !self.map_sfixed32_sfixed32.is_empty() {
                for (k, v) in self.map_sfixed32_sfixed32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32)
                        + 4
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    n += pbrs::rt::key_len_value_len(64, inner);
                }
            }
            if !self.map_sfixed64_sfixed64.is_empty() {
                for (k, v) in self.map_sfixed64_sfixed64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I64)
                        + 8
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    n += pbrs::rt::key_len_value_len(65, inner);
                }
            }
            if !self.map_int32_float.is_empty() {
                for (k, v) in self.map_int32_float.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    n += pbrs::rt::key_len_value_len(66, inner);
                }
            }
            if !self.map_int32_double.is_empty() {
                for (k, v) in self.map_int32_double.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    n += pbrs::rt::key_len_value_len(67, inner);
                }
            }
            if !self.map_bool_bool.is_empty() {
                for (k, v) in self.map_bool_bool.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*v));
                    n += pbrs::rt::key_len_value_len(68, inner);
                }
            }
            if !self.map_string_string.is_empty() {
                for (k, v) in self.map_string_string.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
                    n += pbrs::rt::key_len_value_len(69, inner);
                }
            }
            if !self.map_string_bytes.is_empty() {
                for (k, v) in self.map_string_bytes.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
                    n += pbrs::rt::key_len_value_len(70, inner);
                }
            }
            if !self.map_string_nested_message.is_empty() {
                for (k, v) in self.map_string_nested_message.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.compute_size());
                    n += pbrs::rt::key_len_value_len(71, inner);
                }
            }
            if !self.map_string_foreign_message.is_empty() {
                for (k, v) in self.map_string_foreign_message.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.compute_size());
                    n += pbrs::rt::key_len_value_len(72, inner);
                }
            }
            if !self.map_string_nested_enum.is_empty() {
                for (k, v) in self.map_string_nested_enum.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    n += pbrs::rt::key_len_value_len(73, inner);
                }
            }
            if !self.map_string_foreign_enum.is_empty() {
                for (k, v) in self.map_string_foreign_enum.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    n += pbrs::rt::key_len_value_len(74, inner);
                }
            }
            if let Some(p) = self.packed_fixed32.packed_bytes() {
                n += pbrs::rt::key_len_value_len(81, p.len() as u64);
            } else if !self.packed_fixed32.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_fixed32.iter() {
                    payload += 4;
                }
                n += pbrs::rt::key_len_value_len(81, payload);
            }
            if let Some(p) = self.packed_fixed64.packed_bytes() {
                n += pbrs::rt::key_len_value_len(82, p.len() as u64);
            } else if !self.packed_fixed64.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_fixed64.iter() {
                    payload += 8;
                }
                n += pbrs::rt::key_len_value_len(82, payload);
            }
            if let Some(p) = self.packed_float.packed_bytes() {
                n += pbrs::rt::key_len_value_len(85, p.len() as u64);
            } else if !self.packed_float.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_float.iter() {
                    payload += 4;
                }
                n += pbrs::rt::key_len_value_len(85, payload);
            }
            if let Some(v) = self.oneof_uint32 {
                n += pbrs::rt::tag_len(111, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(p) = self.oneof_nested_message.wire_bytes() {
                n += pbrs::rt::key_len_value_len(112, p.len() as u64);
            } else if let Some(m) = self.oneof_nested_message.as_deref() {
                n += pbrs::rt::key_len_value_len(112, m.compute_size());
            }
            if let Some(s) = &self.oneof_string {
                n += pbrs::rt::key_len_value_len(113, s.as_bytes().len() as u64);
            }
            if let Some(s) = &self.oneof_bytes {
                n += pbrs::rt::key_len_value_len(114, s.as_bytes().len() as u64);
            }
            if let Some(v) = self.oneof_bool.get() {
                n += pbrs::rt::tag_len(115, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len(u64::from(v));
            }
            if let Some(v) = self.oneof_uint64 {
                n += pbrs::rt::tag_len(116, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.oneof_float {
                n += pbrs::rt::tag_len(117, pbrs::rt::WIRE_I32) + 4;
            }
            if let Some(v) = self.oneof_double {
                n += pbrs::rt::tag_len(118, pbrs::rt::WIRE_I64) + 8;
            }
            if let Some(v) = self.oneof_enum {
                n += pbrs::rt::tag_len(119, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if let Some(v) = self.oneof_null_value {
                n += pbrs::rt::tag_len(120, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((v) as u64);
            }
            if self.optional_null_value != 0 {
                n += pbrs::rt::tag_len(307, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.optional_null_value) as u64);
            }
            if self.fieldname1 != 0 {
                n += pbrs::rt::tag_len(401, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.fieldname1) as u64);
            }
            if self.field_name2 != 0 {
                n += pbrs::rt::tag_len(402, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.field_name2) as u64);
            }
            if self._field_name3 != 0 {
                n += pbrs::rt::tag_len(403, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self._field_name3) as u64);
            }
            if self.field__name4_ != 0 {
                n += pbrs::rt::tag_len(404, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.field__name4_) as u64);
            }
            if self.field0name5 != 0 {
                n += pbrs::rt::tag_len(405, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.field0name5) as u64);
            }
            if self.field_0_name6 != 0 {
                n += pbrs::rt::tag_len(406, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.field_0_name6) as u64);
            }
            if self.fieldName7 != 0 {
                n += pbrs::rt::tag_len(407, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.fieldName7) as u64);
            }
            if self.FieldName8 != 0 {
                n += pbrs::rt::tag_len(408, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.FieldName8) as u64);
            }
            if self.field_Name9 != 0 {
                n += pbrs::rt::tag_len(409, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.field_Name9) as u64);
            }
            if self.Field_Name10 != 0 {
                n += pbrs::rt::tag_len(410, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.Field_Name10) as u64);
            }
            if self.FIELD_NAME11 != 0 {
                n += pbrs::rt::tag_len(411, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.FIELD_NAME11) as u64);
            }
            if self.FIELD_name12 != 0 {
                n += pbrs::rt::tag_len(412, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.FIELD_name12) as u64);
            }
            if self.__field_name13 != 0 {
                n += pbrs::rt::tag_len(413, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.__field_name13) as u64);
            }
            if self.__Field_name14 != 0 {
                n += pbrs::rt::tag_len(414, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.__Field_name14) as u64);
            }
            if self.field__name15 != 0 {
                n += pbrs::rt::tag_len(415, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.field__name15) as u64);
            }
            if self.field__Name16 != 0 {
                n += pbrs::rt::tag_len(416, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.field__Name16) as u64);
            }
            if self.field_name17__ != 0 {
                n += pbrs::rt::tag_len(417, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.field_name17__) as u64);
            }
            if self.Field_name18__ != 0 {
                n += pbrs::rt::tag_len(418, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.Field_name18__) as u64);
            }
            if let Some(c) = self.cold.as_deref() {
                if let Some(p) = c.repeated_int32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(31, p.len() as u64);
                } else if !c.repeated_int32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_int32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(31, payload);
                }
                if let Some(p) = c.repeated_int64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(32, p.len() as u64);
                } else if !c.repeated_int64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_int64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(32, payload);
                }
                if let Some(p) = c.repeated_uint32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(33, p.len() as u64);
                } else if !c.repeated_uint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_uint32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(33, payload);
                }
                if let Some(p) = c.repeated_uint64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(34, p.len() as u64);
                } else if !c.repeated_uint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_uint64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(34, payload);
                }
                if let Some(p) = c.repeated_sint32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(35, p.len() as u64);
                } else if !c.repeated_sint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sint32.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*t));
                    }
                    n += pbrs::rt::key_len_value_len(35, payload);
                }
                if let Some(p) = c.repeated_sint64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(36, p.len() as u64);
                } else if !c.repeated_sint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sint64.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*t));
                    }
                    n += pbrs::rt::key_len_value_len(36, payload);
                }
                if let Some(p) = c.repeated_fixed32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(37, p.len() as u64);
                } else if !c.repeated_fixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_fixed32.iter() {
                        payload += 4;
                    }
                    n += pbrs::rt::key_len_value_len(37, payload);
                }
                if let Some(p) = c.repeated_fixed64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(38, p.len() as u64);
                } else if !c.repeated_fixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_fixed64.iter() {
                        payload += 8;
                    }
                    n += pbrs::rt::key_len_value_len(38, payload);
                }
                if let Some(p) = c.repeated_sfixed32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(39, p.len() as u64);
                } else if !c.repeated_sfixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sfixed32.iter() {
                        payload += 4;
                    }
                    n += pbrs::rt::key_len_value_len(39, payload);
                }
                if let Some(p) = c.repeated_sfixed64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(40, p.len() as u64);
                } else if !c.repeated_sfixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sfixed64.iter() {
                        payload += 8;
                    }
                    n += pbrs::rt::key_len_value_len(40, payload);
                }
                if let Some(p) = c.repeated_float.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(41, p.len() as u64);
                } else if !c.repeated_float.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_float.iter() {
                        payload += 4;
                    }
                    n += pbrs::rt::key_len_value_len(41, payload);
                }
                if let Some(p) = c.repeated_double.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(42, p.len() as u64);
                } else if !c.repeated_double.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_double.iter() {
                        payload += 8;
                    }
                    n += pbrs::rt::key_len_value_len(42, payload);
                }
                if let Some(p) = c.repeated_bool.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(43, p.len() as u64);
                } else if !c.repeated_bool.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_bool.iter() {
                        payload += pbrs::rt::varint_len(u64::from(*t));
                    }
                    n += pbrs::rt::key_len_value_len(43, payload);
                }
                for t in c.repeated_foreign_message.iter() {
                    n += pbrs::rt::key_len_value_len(49, t.compute_size());
                }
                if let Some(p) = c.repeated_nested_enum.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(51, p.len() as u64);
                } else if !c.repeated_nested_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_nested_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(51, payload);
                }
                if let Some(p) = c.repeated_foreign_enum.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(52, p.len() as u64);
                } else if !c.repeated_foreign_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_foreign_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(52, payload);
                }
                if let Some(p) = c.packed_int32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(75, p.len() as u64);
                } else if !c.packed_int32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_int32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(75, payload);
                }
                if let Some(p) = c.packed_int64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(76, p.len() as u64);
                } else if !c.packed_int64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_int64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(76, payload);
                }
                if let Some(p) = c.packed_uint32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(77, p.len() as u64);
                } else if !c.packed_uint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_uint32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(77, payload);
                }
                if let Some(p) = c.packed_uint64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(78, p.len() as u64);
                } else if !c.packed_uint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_uint64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(78, payload);
                }
                if let Some(p) = c.packed_sint32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(79, p.len() as u64);
                } else if !c.packed_sint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sint32.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*t));
                    }
                    n += pbrs::rt::key_len_value_len(79, payload);
                }
                if let Some(p) = c.packed_sint64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(80, p.len() as u64);
                } else if !c.packed_sint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sint64.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*t));
                    }
                    n += pbrs::rt::key_len_value_len(80, payload);
                }
                if let Some(p) = c.packed_sfixed32.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(83, p.len() as u64);
                } else if !c.packed_sfixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sfixed32.iter() {
                        payload += 4;
                    }
                    n += pbrs::rt::key_len_value_len(83, payload);
                }
                if let Some(p) = c.packed_sfixed64.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(84, p.len() as u64);
                } else if !c.packed_sfixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sfixed64.iter() {
                        payload += 8;
                    }
                    n += pbrs::rt::key_len_value_len(84, payload);
                }
                if let Some(p) = c.packed_double.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(86, p.len() as u64);
                } else if !c.packed_double.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_double.iter() {
                        payload += 8;
                    }
                    n += pbrs::rt::key_len_value_len(86, payload);
                }
                if let Some(p) = c.packed_bool.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(87, p.len() as u64);
                } else if !c.packed_bool.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_bool.iter() {
                        payload += pbrs::rt::varint_len(u64::from(*t));
                    }
                    n += pbrs::rt::key_len_value_len(87, payload);
                }
                if let Some(p) = c.packed_nested_enum.packed_bytes() {
                    n += pbrs::rt::key_len_value_len(88, p.len() as u64);
                } else if !c.packed_nested_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_nested_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    n += pbrs::rt::key_len_value_len(88, payload);
                }
                for t in c.unpacked_int32.iter() {
                    n += pbrs::rt::tag_len(89, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.unpacked_int64.iter() {
                    n += pbrs::rt::tag_len(90, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.unpacked_uint32.iter() {
                    n += pbrs::rt::tag_len(91, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.unpacked_uint64.iter() {
                    n += pbrs::rt::tag_len(92, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                for t in c.unpacked_sint32.iter() {
                    n += pbrs::rt::tag_len(93, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*t));
                }
                for t in c.unpacked_sint64.iter() {
                    n += pbrs::rt::tag_len(94, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*t));
                }
                for t in c.unpacked_fixed32.iter() {
                    n += pbrs::rt::tag_len(95, pbrs::rt::WIRE_I32) + 4;
                }
                for t in c.unpacked_fixed64.iter() {
                    n += pbrs::rt::tag_len(96, pbrs::rt::WIRE_I64) + 8;
                }
                for t in c.unpacked_sfixed32.iter() {
                    n += pbrs::rt::tag_len(97, pbrs::rt::WIRE_I32) + 4;
                }
                for t in c.unpacked_sfixed64.iter() {
                    n += pbrs::rt::tag_len(98, pbrs::rt::WIRE_I64) + 8;
                }
                for t in c.unpacked_float.iter() {
                    n += pbrs::rt::tag_len(99, pbrs::rt::WIRE_I32) + 4;
                }
                for t in c.unpacked_double.iter() {
                    n += pbrs::rt::tag_len(100, pbrs::rt::WIRE_I64) + 8;
                }
                for t in c.unpacked_bool.iter() {
                    n += pbrs::rt::tag_len(101, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*t));
                }
                for t in c.unpacked_nested_enum.iter() {
                    n += pbrs::rt::tag_len(102, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*t) as u64);
                }
                if let Some(p) = c.optional_bool_wrapper.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(201, p.len() as u64);
                } else if let Some(m) = c.optional_bool_wrapper.as_deref() {
                    n += pbrs::rt::key_len_value_len(201, m.compute_size());
                }
                if let Some(p) = c.optional_int32_wrapper.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(202, p.len() as u64);
                } else if let Some(m) = c.optional_int32_wrapper.as_deref() {
                    n += pbrs::rt::key_len_value_len(202, m.compute_size());
                }
                if let Some(p) = c.optional_int64_wrapper.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(203, p.len() as u64);
                } else if let Some(m) = c.optional_int64_wrapper.as_deref() {
                    n += pbrs::rt::key_len_value_len(203, m.compute_size());
                }
                if let Some(p) = c.optional_uint32_wrapper.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(204, p.len() as u64);
                } else if let Some(m) = c.optional_uint32_wrapper.as_deref() {
                    n += pbrs::rt::key_len_value_len(204, m.compute_size());
                }
                if let Some(p) = c.optional_uint64_wrapper.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(205, p.len() as u64);
                } else if let Some(m) = c.optional_uint64_wrapper.as_deref() {
                    n += pbrs::rt::key_len_value_len(205, m.compute_size());
                }
                if let Some(p) = c.optional_float_wrapper.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(206, p.len() as u64);
                } else if let Some(m) = c.optional_float_wrapper.as_deref() {
                    n += pbrs::rt::key_len_value_len(206, m.compute_size());
                }
                if let Some(p) = c.optional_double_wrapper.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(207, p.len() as u64);
                } else if let Some(m) = c.optional_double_wrapper.as_deref() {
                    n += pbrs::rt::key_len_value_len(207, m.compute_size());
                }
                if let Some(p) = c.optional_string_wrapper.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(208, p.len() as u64);
                } else if let Some(m) = c.optional_string_wrapper.as_deref() {
                    n += pbrs::rt::key_len_value_len(208, m.compute_size());
                }
                if let Some(p) = c.optional_bytes_wrapper.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(209, p.len() as u64);
                } else if let Some(m) = c.optional_bytes_wrapper.as_deref() {
                    n += pbrs::rt::key_len_value_len(209, m.compute_size());
                }
                for t in c.repeated_bool_wrapper.iter() {
                    n += pbrs::rt::key_len_value_len(211, t.compute_size());
                }
                for t in c.repeated_int32_wrapper.iter() {
                    n += pbrs::rt::key_len_value_len(212, t.compute_size());
                }
                for t in c.repeated_int64_wrapper.iter() {
                    n += pbrs::rt::key_len_value_len(213, t.compute_size());
                }
                for t in c.repeated_uint32_wrapper.iter() {
                    n += pbrs::rt::key_len_value_len(214, t.compute_size());
                }
                for t in c.repeated_uint64_wrapper.iter() {
                    n += pbrs::rt::key_len_value_len(215, t.compute_size());
                }
                for t in c.repeated_float_wrapper.iter() {
                    n += pbrs::rt::key_len_value_len(216, t.compute_size());
                }
                for t in c.repeated_double_wrapper.iter() {
                    n += pbrs::rt::key_len_value_len(217, t.compute_size());
                }
                for t in c.repeated_string_wrapper.iter() {
                    n += pbrs::rt::key_len_value_len(218, t.compute_size());
                }
                for t in c.repeated_bytes_wrapper.iter() {
                    n += pbrs::rt::key_len_value_len(219, t.compute_size());
                }
                if let Some(p) = c.optional_duration.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(301, p.len() as u64);
                } else if let Some(m) = c.optional_duration.as_deref() {
                    n += pbrs::rt::key_len_value_len(301, m.compute_size());
                }
                if let Some(p) = c.optional_timestamp.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(302, p.len() as u64);
                } else if let Some(m) = c.optional_timestamp.as_deref() {
                    n += pbrs::rt::key_len_value_len(302, m.compute_size());
                }
                if let Some(p) = c.optional_field_mask.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(303, p.len() as u64);
                } else if let Some(m) = c.optional_field_mask.as_deref() {
                    n += pbrs::rt::key_len_value_len(303, m.compute_size());
                }
                if let Some(p) = c.optional_struct.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(304, p.len() as u64);
                } else if let Some(m) = c.optional_struct.as_deref() {
                    n += pbrs::rt::key_len_value_len(304, m.compute_size());
                }
                if let Some(p) = c.optional_any.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(305, p.len() as u64);
                } else if let Some(m) = c.optional_any.as_deref() {
                    n += pbrs::rt::key_len_value_len(305, m.compute_size());
                }
                if let Some(p) = c.optional_value.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(306, p.len() as u64);
                } else if let Some(m) = c.optional_value.as_deref() {
                    n += pbrs::rt::key_len_value_len(306, m.compute_size());
                }
                if let Some(p) = c.optional_empty.wire_bytes() {
                    n += pbrs::rt::key_len_value_len(308, p.len() as u64);
                } else if let Some(m) = c.optional_empty.as_deref() {
                    n += pbrs::rt::key_len_value_len(308, m.compute_size());
                }
                for t in c.repeated_duration.iter() {
                    n += pbrs::rt::key_len_value_len(311, t.compute_size());
                }
                for t in c.repeated_timestamp.iter() {
                    n += pbrs::rt::key_len_value_len(312, t.compute_size());
                }
                for t in c.repeated_fieldmask.iter() {
                    n += pbrs::rt::key_len_value_len(313, t.compute_size());
                }
                for t in c.repeated_any.iter() {
                    n += pbrs::rt::key_len_value_len(315, t.compute_size());
                }
                for t in c.repeated_value.iter() {
                    n += pbrs::rt::key_len_value_len(316, t.compute_size());
                }
                for t in c.repeated_list_value.iter() {
                    n += pbrs::rt::key_len_value_len(317, t.compute_size());
                }
                for t in c.repeated_empty.iter() {
                    n += pbrs::rt::key_len_value_len(318, t.compute_size());
                }
                for t in c.repeated_struct.iter() {
                    n += pbrs::rt::key_len_value_len(324, t.compute_size());
                }
            }
            self.cached_size.set(n);
            n
        }
        fn write_to(&self, out: &mut impl pbrs::rt::WireOut) {
            if self.optional_int32 != 0 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.optional_int32 as u64);
            }
            if self.optional_int64 != 0 {
                pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.optional_int64 as u64);
            }
            if self.optional_uint32 != 0 {
                pbrs::rt::encode_tag(out, 3, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.optional_uint32 as u64);
            }
            if self.optional_uint64 != 0 {
                pbrs::rt::encode_tag(out, 4, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.optional_uint64 as u64);
            }
            if self.optional_sint32 != 0 {
                pbrs::rt::encode_tag(out, 5, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(self.optional_sint32));
            }
            if self.optional_sint64 != 0 {
                pbrs::rt::encode_tag(out, 6, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(self.optional_sint64));
            }
            if self.optional_fixed32 != 0 {
                pbrs::rt::encode_tag(out, 7, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(self.optional_fixed32).to_le_bytes());
            }
            if self.optional_fixed64 != 0 {
                pbrs::rt::encode_tag(out, 8, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(self.optional_fixed64).to_le_bytes());
            }
            if self.optional_sfixed32 != 0 {
                pbrs::rt::encode_tag(out, 9, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&((self.optional_sfixed32) as u32).to_le_bytes());
            }
            if self.optional_sfixed64 != 0 {
                pbrs::rt::encode_tag(out, 10, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&((self.optional_sfixed64) as u64).to_le_bytes());
            }
            if self.optional_float.to_bits() != 0 {
                pbrs::rt::encode_tag(out, 11, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(self.optional_float).to_bits().to_le_bytes());
            }
            if self.optional_double.to_bits() != 0 {
                pbrs::rt::encode_tag(out, 12, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(self.optional_double).to_bits().to_le_bytes());
            }
            if self.optional_bool {
                pbrs::rt::encode_tag(out, 13, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, u64::from(self.optional_bool));
            }
            if !self.optional_string.is_empty() {
                pbrs::rt::encode_len_field(out, 14, self.optional_string.as_bytes());
            }
            if !self.optional_bytes.is_empty() {
                pbrs::rt::encode_len_field(out, 15, self.optional_bytes.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 self.optional_nested_enum != 0 {
                pbrs::rt::encode_tag(out, 21, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.optional_nested_enum as u64);
            }
            if self.optional_foreign_enum != 0 {
                pbrs::rt::encode_tag(out, 22, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.optional_foreign_enum as u64);
            }
            if self.optional_aliased_enum != 0 {
                pbrs::rt::encode_tag(out, 23, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.optional_aliased_enum as u64);
            }
            if !self.optional_string_piece.is_empty() {
                pbrs::rt::encode_len_field(out, 24, self.optional_string_piece.as_bytes());
            }
            if !self.optional_cord.is_empty() {
                pbrs::rt::encode_len_field(out, 25, self.optional_cord.as_bytes());
            }
            if let Some(p) = self.recursive_message.wire_bytes() {
                pbrs::rt::encode_len_header(out, 27, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.recursive_message.as_deref() {
                pbrs::rt::encode_len_header(out, 27, m.compute_size());
                m.write_to(out);
            }
            for t in self.repeated_string.iter() {
                pbrs::rt::encode_len_field(out, 44, t.as_bytes());
            }
            for t in self.repeated_bytes.iter() {
                pbrs::rt::encode_len_field(out, 45, t.as_bytes());
            }
            for t in self.repeated_nested_message.iter() {
                pbrs::rt::encode_len_header(out, 48, t.compute_size());
                t.write_to(out);
            }
            for t in self.repeated_string_piece.iter() {
                pbrs::rt::encode_len_field(out, 54, t.as_bytes());
            }
            for t in self.repeated_cord.iter() {
                pbrs::rt::encode_len_field(out, 55, t.as_bytes());
            }
            if !self.map_int32_int32.is_empty() {
                for (k, v) in self.map_int32_int32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    pbrs::rt::encode_tag(out, 56, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k as u64);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v as u64);
                }
            }
            if !self.map_int64_int64.is_empty() {
                for (k, v) in self.map_int64_int64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    pbrs::rt::encode_tag(out, 57, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k as u64);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v as u64);
                }
            }
            if !self.map_uint32_uint32.is_empty() {
                for (k, v) in self.map_uint32_uint32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*v));
                    pbrs::rt::encode_tag(out, 58, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k as u64);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v as u64);
                }
            }
            if !self.map_uint64_uint64.is_empty() {
                for (k, v) in self.map_uint64_uint64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(*k)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(*v);
                    pbrs::rt::encode_tag(out, 59, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v);
                }
            }
            if !self.map_sint32_sint32.is_empty() {
                for (k, v) in self.map_sint32_sint32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*v));
                    pbrs::rt::encode_tag(out, 60, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(*k));
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(*v));
                }
            }
            if !self.map_sint64_sint64.is_empty() {
                for (k, v) in self.map_sint64_sint64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*v));
                    pbrs::rt::encode_tag(out, 61, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(*k));
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(*v));
                }
            }
            if !self.map_fixed32_fixed32.is_empty() {
                for (k, v) in self.map_fixed32_fixed32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32)
                        + 4
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    pbrs::rt::encode_tag(out, 62, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I32);
                    out.extend_from_slice(&k.to_le_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I32);
                    out.extend_from_slice(&v.to_le_bytes());
                }
            }
            if !self.map_fixed64_fixed64.is_empty() {
                for (k, v) in self.map_fixed64_fixed64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I64)
                        + 8
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    pbrs::rt::encode_tag(out, 63, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I64);
                    out.extend_from_slice(&k.to_le_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I64);
                    out.extend_from_slice(&v.to_le_bytes());
                }
            }
            if !self.map_sfixed32_sfixed32.is_empty() {
                for (k, v) in self.map_sfixed32_sfixed32.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I32)
                        + 4
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    pbrs::rt::encode_tag(out, 64, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I32);
                    out.extend_from_slice(&(*k as u32).to_le_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I32);
                    out.extend_from_slice(&(*v as u32).to_le_bytes());
                }
            }
            if !self.map_sfixed64_sfixed64.is_empty() {
                for (k, v) in self.map_sfixed64_sfixed64.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_I64)
                        + 8
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    pbrs::rt::encode_tag(out, 65, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_I64);
                    out.extend_from_slice(&(*k as u64).to_le_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I64);
                    out.extend_from_slice(&(*v as u64).to_le_bytes());
                }
            }
            if !self.map_int32_float.is_empty() {
                for (k, v) in self.map_int32_float.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I32)
                        + 4;
                    pbrs::rt::encode_tag(out, 66, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k as u64);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I32);
                    out.extend_from_slice(&v.to_bits().to_le_bytes());
                }
            }
            if !self.map_int32_double.is_empty() {
                for (k, v) in self.map_int32_double.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*k) as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_I64)
                        + 8;
                    pbrs::rt::encode_tag(out, 67, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *k as u64);
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_I64);
                    out.extend_from_slice(&v.to_bits().to_le_bytes());
                }
            }
            if !self.map_bool_bool.is_empty() {
                for (k, v) in self.map_bool_bool.pairs() {
                    let inner = pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*k))
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len(u64::from(*v));
                    pbrs::rt::encode_tag(out, 68, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, u64::from(*k));
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, u64::from(*v));
                }
            }
            if !self.map_string_string.is_empty() {
                for (k, v) in self.map_string_string.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
                    pbrs::rt::encode_tag(out, 69, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_len_field(out, 2, v.as_bytes());
                }
            }
            if !self.map_string_bytes.is_empty() {
                for (k, v) in self.map_string_bytes.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.as_bytes().len() as u64);
                    pbrs::rt::encode_tag(out, 70, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_len_field(out, 2, v.as_bytes());
                }
            }
            if !self.map_string_nested_message.is_empty() {
                for (k, v) in self.map_string_nested_message.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.compute_size());
                    pbrs::rt::encode_tag(out, 71, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_len_header(out, 2, v.compute_size());
                    v.write_to(out);
                }
            }
            if !self.map_string_foreign_message.is_empty() {
                for (k, v) in self.map_string_foreign_message.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::key_len_value_len(2, v.compute_size());
                    pbrs::rt::encode_tag(out, 72, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_len_header(out, 2, v.compute_size());
                    v.write_to(out);
                }
            }
            if !self.map_string_nested_enum.is_empty() {
                for (k, v) in self.map_string_nested_enum.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    pbrs::rt::encode_tag(out, 73, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v as u64);
                }
            }
            if !self.map_string_foreign_enum.is_empty() {
                for (k, v) in self.map_string_foreign_enum.pairs() {
                    let inner = pbrs::rt::key_len_value_len(1, k.as_bytes().len() as u64)
                        + pbrs::rt::tag_len(2, pbrs::rt::WIRE_VARINT)
                        + pbrs::rt::varint_len((*v) as u64);
                    pbrs::rt::encode_tag(out, 74, pbrs::rt::WIRE_LEN);
                    pbrs::rt::encode_varint(out, inner);
                    pbrs::rt::encode_len_field(out, 1, k.as_bytes());
                    pbrs::rt::encode_tag(out, 2, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *v as u64);
                }
            }
            if let Some(p) = self.packed_fixed32.packed_bytes() {
                pbrs::rt::encode_len_header(out, 81, p.len() as u64);
                out.extend_from_slice(p);
            } else if !self.packed_fixed32.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_fixed32.iter() {
                    payload += 4;
                }
                pbrs::rt::encode_len_header(out, 81, payload);
                for t in self.packed_fixed32.iter() {
                    (out).extend_from_slice(&(*t).to_le_bytes());
                }
            }
            if let Some(p) = self.packed_fixed64.packed_bytes() {
                pbrs::rt::encode_len_header(out, 82, p.len() as u64);
                out.extend_from_slice(p);
            } else if !self.packed_fixed64.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_fixed64.iter() {
                    payload += 8;
                }
                pbrs::rt::encode_len_header(out, 82, payload);
                for t in self.packed_fixed64.iter() {
                    (out).extend_from_slice(&(*t).to_le_bytes());
                }
            }
            if let Some(p) = self.packed_float.packed_bytes() {
                pbrs::rt::encode_len_header(out, 85, p.len() as u64);
                out.extend_from_slice(p);
            } else if !self.packed_float.is_empty() {
                let mut payload = 0u64;
                for t in self.packed_float.iter() {
                    payload += 4;
                }
                pbrs::rt::encode_len_header(out, 85, payload);
                for t in self.packed_float.iter() {
                    (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                }
            }
            if let Some(v) = self.oneof_uint32 {
                pbrs::rt::encode_tag(out, 111, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(p) = self.oneof_nested_message.wire_bytes() {
                pbrs::rt::encode_len_header(out, 112, p.len() as u64);
                out.extend_from_slice(p);
            } else if let Some(m) = self.oneof_nested_message.as_deref() {
                pbrs::rt::encode_len_header(out, 112, m.compute_size());
                m.write_to(out);
            }
            if let Some(s) = &self.oneof_string {
                pbrs::rt::encode_len_field(out, 113, s.as_bytes());
            }
            if let Some(s) = &self.oneof_bytes {
                pbrs::rt::encode_len_field(out, 114, s.as_bytes());
            }
            if let Some(v) = self.oneof_bool.get() {
                pbrs::rt::encode_tag(out, 115, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, u64::from(v));
            }
            if let Some(v) = self.oneof_uint64 {
                pbrs::rt::encode_tag(out, 116, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.oneof_float {
                pbrs::rt::encode_tag(out, 117, pbrs::rt::WIRE_I32);
                (out).extend_from_slice(&(v).to_bits().to_le_bytes());
            }
            if let Some(v) = self.oneof_double {
                pbrs::rt::encode_tag(out, 118, pbrs::rt::WIRE_I64);
                (out).extend_from_slice(&(v).to_bits().to_le_bytes());
            }
            if let Some(v) = self.oneof_enum {
                pbrs::rt::encode_tag(out, 119, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if let Some(v) = self.oneof_null_value {
                pbrs::rt::encode_tag(out, 120, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, v as u64);
            }
            if self.optional_null_value != 0 {
                pbrs::rt::encode_tag(out, 307, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.optional_null_value as u64);
            }
            if self.fieldname1 != 0 {
                pbrs::rt::encode_tag(out, 401, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.fieldname1 as u64);
            }
            if self.field_name2 != 0 {
                pbrs::rt::encode_tag(out, 402, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.field_name2 as u64);
            }
            if self._field_name3 != 0 {
                pbrs::rt::encode_tag(out, 403, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self._field_name3 as u64);
            }
            if self.field__name4_ != 0 {
                pbrs::rt::encode_tag(out, 404, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.field__name4_ as u64);
            }
            if self.field0name5 != 0 {
                pbrs::rt::encode_tag(out, 405, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.field0name5 as u64);
            }
            if self.field_0_name6 != 0 {
                pbrs::rt::encode_tag(out, 406, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.field_0_name6 as u64);
            }
            if self.fieldName7 != 0 {
                pbrs::rt::encode_tag(out, 407, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.fieldName7 as u64);
            }
            if self.FieldName8 != 0 {
                pbrs::rt::encode_tag(out, 408, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.FieldName8 as u64);
            }
            if self.field_Name9 != 0 {
                pbrs::rt::encode_tag(out, 409, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.field_Name9 as u64);
            }
            if self.Field_Name10 != 0 {
                pbrs::rt::encode_tag(out, 410, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.Field_Name10 as u64);
            }
            if self.FIELD_NAME11 != 0 {
                pbrs::rt::encode_tag(out, 411, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.FIELD_NAME11 as u64);
            }
            if self.FIELD_name12 != 0 {
                pbrs::rt::encode_tag(out, 412, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.FIELD_name12 as u64);
            }
            if self.__field_name13 != 0 {
                pbrs::rt::encode_tag(out, 413, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.__field_name13 as u64);
            }
            if self.__Field_name14 != 0 {
                pbrs::rt::encode_tag(out, 414, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.__Field_name14 as u64);
            }
            if self.field__name15 != 0 {
                pbrs::rt::encode_tag(out, 415, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.field__name15 as u64);
            }
            if self.field__Name16 != 0 {
                pbrs::rt::encode_tag(out, 416, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.field__Name16 as u64);
            }
            if self.field_name17__ != 0 {
                pbrs::rt::encode_tag(out, 417, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.field_name17__ as u64);
            }
            if self.Field_name18__ != 0 {
                pbrs::rt::encode_tag(out, 418, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.Field_name18__ as u64);
            }
            if let Some(c) = self.cold.as_deref() {
                if let Some(p) = c.repeated_int32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 31, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_int32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_int32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 31, payload);
                    for t in c.repeated_int32.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.repeated_int64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 32, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_int64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_int64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 32, payload);
                    for t in c.repeated_int64.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.repeated_uint32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 33, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_uint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_uint32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 33, payload);
                    for t in c.repeated_uint32.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.repeated_uint64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 34, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_uint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_uint64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 34, payload);
                    for t in c.repeated_uint64.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.repeated_sint32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 35, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_sint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sint32.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*t));
                    }
                    pbrs::rt::encode_len_header(out, 35, payload);
                    for t in c.repeated_sint32.iter() {
                        pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(*t));
                    }
                }
                if let Some(p) = c.repeated_sint64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 36, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_sint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sint64.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*t));
                    }
                    pbrs::rt::encode_len_header(out, 36, payload);
                    for t in c.repeated_sint64.iter() {
                        pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(*t));
                    }
                }
                if let Some(p) = c.repeated_fixed32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 37, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_fixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_fixed32.iter() {
                        payload += 4;
                    }
                    pbrs::rt::encode_len_header(out, 37, payload);
                    for t in c.repeated_fixed32.iter() {
                        (out).extend_from_slice(&(*t).to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_fixed64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 38, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_fixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_fixed64.iter() {
                        payload += 8;
                    }
                    pbrs::rt::encode_len_header(out, 38, payload);
                    for t in c.repeated_fixed64.iter() {
                        (out).extend_from_slice(&(*t).to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_sfixed32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 39, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_sfixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sfixed32.iter() {
                        payload += 4;
                    }
                    pbrs::rt::encode_len_header(out, 39, payload);
                    for t in c.repeated_sfixed32.iter() {
                        (out).extend_from_slice(&((*t) as u32).to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_sfixed64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 40, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_sfixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_sfixed64.iter() {
                        payload += 8;
                    }
                    pbrs::rt::encode_len_header(out, 40, payload);
                    for t in c.repeated_sfixed64.iter() {
                        (out).extend_from_slice(&((*t) as u64).to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_float.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 41, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_float.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_float.iter() {
                        payload += 4;
                    }
                    pbrs::rt::encode_len_header(out, 41, payload);
                    for t in c.repeated_float.iter() {
                        (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_double.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 42, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_double.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_double.iter() {
                        payload += 8;
                    }
                    pbrs::rt::encode_len_header(out, 42, payload);
                    for t in c.repeated_double.iter() {
                        (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                    }
                }
                if let Some(p) = c.repeated_bool.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 43, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_bool.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_bool.iter() {
                        payload += pbrs::rt::varint_len(u64::from(*t));
                    }
                    pbrs::rt::encode_len_header(out, 43, payload);
                    for t in c.repeated_bool.iter() {
                        pbrs::rt::encode_varint(out, u64::from(*t));
                    }
                }
                for t in c.repeated_foreign_message.iter() {
                    pbrs::rt::encode_len_header(out, 49, t.compute_size());
                    t.write_to(out);
                }
                if let Some(p) = c.repeated_nested_enum.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 51, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_nested_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_nested_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 51, payload);
                    for t in c.repeated_nested_enum.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.repeated_foreign_enum.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 52, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.repeated_foreign_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.repeated_foreign_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 52, payload);
                    for t in c.repeated_foreign_enum.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.packed_int32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 75, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_int32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_int32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 75, payload);
                    for t in c.packed_int32.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.packed_int64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 76, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_int64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_int64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 76, payload);
                    for t in c.packed_int64.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.packed_uint32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 77, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_uint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_uint32.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 77, payload);
                    for t in c.packed_uint32.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.packed_uint64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 78, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_uint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_uint64.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 78, payload);
                    for t in c.packed_uint64.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                if let Some(p) = c.packed_sint32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 79, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_sint32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sint32.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag32(*t));
                    }
                    pbrs::rt::encode_len_header(out, 79, payload);
                    for t in c.packed_sint32.iter() {
                        pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(*t));
                    }
                }
                if let Some(p) = c.packed_sint64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 80, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_sint64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sint64.iter() {
                        payload += pbrs::rt::varint_len(pbrs::rt::encode_zigzag64(*t));
                    }
                    pbrs::rt::encode_len_header(out, 80, payload);
                    for t in c.packed_sint64.iter() {
                        pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(*t));
                    }
                }
                if let Some(p) = c.packed_sfixed32.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 83, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_sfixed32.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sfixed32.iter() {
                        payload += 4;
                    }
                    pbrs::rt::encode_len_header(out, 83, payload);
                    for t in c.packed_sfixed32.iter() {
                        (out).extend_from_slice(&((*t) as u32).to_le_bytes());
                    }
                }
                if let Some(p) = c.packed_sfixed64.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 84, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_sfixed64.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_sfixed64.iter() {
                        payload += 8;
                    }
                    pbrs::rt::encode_len_header(out, 84, payload);
                    for t in c.packed_sfixed64.iter() {
                        (out).extend_from_slice(&((*t) as u64).to_le_bytes());
                    }
                }
                if let Some(p) = c.packed_double.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 86, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_double.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_double.iter() {
                        payload += 8;
                    }
                    pbrs::rt::encode_len_header(out, 86, payload);
                    for t in c.packed_double.iter() {
                        (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                    }
                }
                if let Some(p) = c.packed_bool.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 87, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_bool.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_bool.iter() {
                        payload += pbrs::rt::varint_len(u64::from(*t));
                    }
                    pbrs::rt::encode_len_header(out, 87, payload);
                    for t in c.packed_bool.iter() {
                        pbrs::rt::encode_varint(out, u64::from(*t));
                    }
                }
                if let Some(p) = c.packed_nested_enum.packed_bytes() {
                    pbrs::rt::encode_len_header(out, 88, p.len() as u64);
                    out.extend_from_slice(p);
                } else if !c.packed_nested_enum.is_empty() {
                    let mut payload = 0u64;
                    for t in c.packed_nested_enum.iter() {
                        payload += pbrs::rt::varint_len((*t) as u64);
                    }
                    pbrs::rt::encode_len_header(out, 88, payload);
                    for t in c.packed_nested_enum.iter() {
                        pbrs::rt::encode_varint(out, *t as u64);
                    }
                }
                for t in c.unpacked_int32.iter() {
                    pbrs::rt::encode_tag(out, 89, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.unpacked_int64.iter() {
                    pbrs::rt::encode_tag(out, 90, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.unpacked_uint32.iter() {
                    pbrs::rt::encode_tag(out, 91, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.unpacked_uint64.iter() {
                    pbrs::rt::encode_tag(out, 92, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                for t in c.unpacked_sint32.iter() {
                    pbrs::rt::encode_tag(out, 93, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag32(*t));
                }
                for t in c.unpacked_sint64.iter() {
                    pbrs::rt::encode_tag(out, 94, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, pbrs::rt::encode_zigzag64(*t));
                }
                for t in c.unpacked_fixed32.iter() {
                    pbrs::rt::encode_tag(out, 95, pbrs::rt::WIRE_I32);
                    (out).extend_from_slice(&(*t).to_le_bytes());
                }
                for t in c.unpacked_fixed64.iter() {
                    pbrs::rt::encode_tag(out, 96, pbrs::rt::WIRE_I64);
                    (out).extend_from_slice(&(*t).to_le_bytes());
                }
                for t in c.unpacked_sfixed32.iter() {
                    pbrs::rt::encode_tag(out, 97, pbrs::rt::WIRE_I32);
                    (out).extend_from_slice(&((*t) as u32).to_le_bytes());
                }
                for t in c.unpacked_sfixed64.iter() {
                    pbrs::rt::encode_tag(out, 98, pbrs::rt::WIRE_I64);
                    (out).extend_from_slice(&((*t) as u64).to_le_bytes());
                }
                for t in c.unpacked_float.iter() {
                    pbrs::rt::encode_tag(out, 99, pbrs::rt::WIRE_I32);
                    (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                }
                for t in c.unpacked_double.iter() {
                    pbrs::rt::encode_tag(out, 100, pbrs::rt::WIRE_I64);
                    (out).extend_from_slice(&(*t).to_bits().to_le_bytes());
                }
                for t in c.unpacked_bool.iter() {
                    pbrs::rt::encode_tag(out, 101, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, u64::from(*t));
                }
                for t in c.unpacked_nested_enum.iter() {
                    pbrs::rt::encode_tag(out, 102, pbrs::rt::WIRE_VARINT);
                    pbrs::rt::encode_varint(out, *t as u64);
                }
                if let Some(p) = c.optional_bool_wrapper.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 201, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_bool_wrapper.as_deref() {
                    pbrs::rt::encode_len_header(out, 201, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_int32_wrapper.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 202, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_int32_wrapper.as_deref() {
                    pbrs::rt::encode_len_header(out, 202, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_int64_wrapper.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 203, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_int64_wrapper.as_deref() {
                    pbrs::rt::encode_len_header(out, 203, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_uint32_wrapper.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 204, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_uint32_wrapper.as_deref() {
                    pbrs::rt::encode_len_header(out, 204, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_uint64_wrapper.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 205, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_uint64_wrapper.as_deref() {
                    pbrs::rt::encode_len_header(out, 205, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_float_wrapper.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 206, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_float_wrapper.as_deref() {
                    pbrs::rt::encode_len_header(out, 206, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_double_wrapper.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 207, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_double_wrapper.as_deref() {
                    pbrs::rt::encode_len_header(out, 207, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_string_wrapper.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 208, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_string_wrapper.as_deref() {
                    pbrs::rt::encode_len_header(out, 208, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_bytes_wrapper.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 209, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_bytes_wrapper.as_deref() {
                    pbrs::rt::encode_len_header(out, 209, m.compute_size());
                    m.write_to(out);
                }
                for t in c.repeated_bool_wrapper.iter() {
                    pbrs::rt::encode_len_header(out, 211, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_int32_wrapper.iter() {
                    pbrs::rt::encode_len_header(out, 212, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_int64_wrapper.iter() {
                    pbrs::rt::encode_len_header(out, 213, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_uint32_wrapper.iter() {
                    pbrs::rt::encode_len_header(out, 214, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_uint64_wrapper.iter() {
                    pbrs::rt::encode_len_header(out, 215, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_float_wrapper.iter() {
                    pbrs::rt::encode_len_header(out, 216, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_double_wrapper.iter() {
                    pbrs::rt::encode_len_header(out, 217, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_string_wrapper.iter() {
                    pbrs::rt::encode_len_header(out, 218, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_bytes_wrapper.iter() {
                    pbrs::rt::encode_len_header(out, 219, t.compute_size());
                    t.write_to(out);
                }
                if let Some(p) = c.optional_duration.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 301, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_duration.as_deref() {
                    pbrs::rt::encode_len_header(out, 301, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_timestamp.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 302, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_timestamp.as_deref() {
                    pbrs::rt::encode_len_header(out, 302, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_field_mask.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 303, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_field_mask.as_deref() {
                    pbrs::rt::encode_len_header(out, 303, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_struct.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 304, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_struct.as_deref() {
                    pbrs::rt::encode_len_header(out, 304, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_any.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 305, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_any.as_deref() {
                    pbrs::rt::encode_len_header(out, 305, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_value.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 306, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_value.as_deref() {
                    pbrs::rt::encode_len_header(out, 306, m.compute_size());
                    m.write_to(out);
                }
                if let Some(p) = c.optional_empty.wire_bytes() {
                    pbrs::rt::encode_len_header(out, 308, p.len() as u64);
                    out.extend_from_slice(p);
                } else if let Some(m) = c.optional_empty.as_deref() {
                    pbrs::rt::encode_len_header(out, 308, m.compute_size());
                    m.write_to(out);
                }
                for t in c.repeated_duration.iter() {
                    pbrs::rt::encode_len_header(out, 311, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_timestamp.iter() {
                    pbrs::rt::encode_len_header(out, 312, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_fieldmask.iter() {
                    pbrs::rt::encode_len_header(out, 313, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_any.iter() {
                    pbrs::rt::encode_len_header(out, 315, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_value.iter() {
                    pbrs::rt::encode_len_header(out, 316, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_list_value.iter() {
                    pbrs::rt::encode_len_header(out, 317, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_empty.iter() {
                    pbrs::rt::encode_len_header(out, 318, t.compute_size());
                    t.write_to(out);
                }
                for t in c.repeated_struct.iter() {
                    pbrs::rt::encode_len_header(out, 324, t.compute_size());
                    t.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.proto3.TestAllTypesProto3")
                .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.proto3.TestAllTypesProto3")
                .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.proto3.TestAllTypesProto3")
                .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.proto3.TestAllTypesProto3")
                .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.proto3.TestAllTypesProto3")
                .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!(
        TestAllTypesProto3,
        TestAllTypesProto3View,
        TestAllTypesProto3Mut
    );
    fn decode_map_entry_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_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_TestAllTypesProto3_map_string_string_69(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, pbrs::rt::LazyStr), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = pbrs::rt::LazyStr::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    val = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesProto3_map_string_bytes_70(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, pbrs::rt::LazyBytes), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = pbrs::rt::LazyBytes::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    val = pbrs::rt::LazyBytes::from_wire_span(wire, s, e);
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesProto3_map_string_nested_message_71(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, NestedMessage), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = NestedMessage::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    let mut ip = 0;
                    let mut sw = None;
                    val.merge_inner(&data[s..e], &mut sw, &mut ip, depth, true, None)?;
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesProto3_map_string_foreign_message_72(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, ForeignMessage), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = ForeignMessage::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    let mut ip = 0;
                    let mut sw = None;
                    val.merge_inner(&data[s..e], &mut sw, &mut ip, depth, true, None)?;
                }
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesProto3_map_string_nested_enum_73(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, i32), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = i32::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_VARINT) => val = pbrs::rt::decode_varint(data, &mut pos)? as i32,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    fn decode_map_entry_TestAllTypesProto3_map_string_foreign_enum_74(
        wire: &pbrs::rt::Wire,
        depth: u32,
    ) -> Result<(pbrs::rt::LazyStr, i32), ParseError> {
        let _ = depth;
        let data = wire.as_slice();
        let mut key = pbrs::rt::LazyStr::default();
        let mut val = i32::default();
        let mut pos = 0;
        while pos < data.len() {
            let (n, w) = pbrs::rt::decode_tag(data, &mut pos)?;
            match (n, w) {
                (1, pbrs::rt::WIRE_LEN) => {
                    let (s, e) = pbrs::rt::read_len_span(data, &mut pos)?;
                    std::str::from_utf8(&data[s..e])
                        .map_err(|_| ParseError::new("invalid utf-8"))?;
                    key = pbrs::rt::LazyStr::from_span(wire, s, e);
                }
                (2, pbrs::rt::WIRE_VARINT) => val = pbrs::rt::decode_varint(data, &mut pos)? as i32,
                _ => pbrs::rt::skip_field(data, &mut pos, w)?,
            }
        }
        Ok((key, val))
    }
    #[derive(Clone, Debug)]
    pub struct NestedMessage {
        a: i32,
        corecursive: pbrs::rt::LazyMsg<TestAllTypesProto3>,
        unknown: UnknownFields,
        cached_size: pbrs::rt::CachedSize,
    }
    impl PartialEq for NestedMessage {
        fn eq(&self, other: &Self) -> bool {
            if self.a != other.a {
                return false;
            }
            if self.corecursive != other.corecursive {
                return false;
            }
            self.unknown == other.unknown
        }
    }
    impl Eq for NestedMessage {}
    impl Default for NestedMessage {
        #[inline(always)]
        fn default() -> Self {
            unsafe { pbrs::rt::zeroed_message() }
        }
    }
    impl NestedMessage {
        pub fn new() -> Self {
            Self::default()
        }
        pub const EMPTY_PARSE_OK: bool = true;
        pub const FULL_NAME: &'static str =
            "protobuf_test_messages.proto3.TestAllTypesProto3.NestedMessage";
        pub fn a(&self) -> i32 {
            self.a
        }
        pub fn set_a(&mut self, v: i32) {
            self.cached_size.dirty();
            self.a = v;
        }
        pub fn has_corecursive(&self) -> bool {
            self.corecursive.is_some()
        }
        pub fn corecursive(&self) -> &TestAllTypesProto3 {
            self.corecursive
                .as_deref()
                .unwrap_or(pbrs::gen_support::default_instance_of())
        }
        pub fn corecursive_opt(&self) -> Option<&TestAllTypesProto3> {
            self.corecursive.as_deref()
        }
        pub fn corecursive_view(&self) -> TestAllTypesProto3View<'_> {
            TestAllTypesProto3View(self.corecursive())
        }
        pub fn set_corecursive(&mut self, v: TestAllTypesProto3) {
            self.cached_size.dirty();
            self.corecursive = pbrs::rt::LazyMsg::from_owned(v);
        }
        pub fn corecursive_mut(&mut self) -> &mut TestAllTypesProto3 {
            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 = 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;
                                TestAllTypesProto3::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;
                            TestAllTypesProto3::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 self.a != 0 {
                n += pbrs::rt::tag_len(1, pbrs::rt::WIRE_VARINT)
                    + pbrs::rt::varint_len((self.a) 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 self.a != 0 {
                pbrs::rt::encode_tag(out, 1, pbrs::rt::WIRE_VARINT);
                pbrs::rt::encode_varint(out, self.a 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.proto3.TestAllTypesProto3.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.proto3.TestAllTypesProto3.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.proto3.TestAllTypesProto3.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.proto3.TestAllTypesProto3.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.proto3.TestAllTypesProto3.NestedMessage")
                .ok_or_else(|| ParseError::owned("missing desc".into()))?;
            let d = pbrs::DynamicMessage::from_text_with_pool(desc, Some(pool), text)?;
            let b = pbrs::Serialize::serialize(&d).map_err(|e| ParseError::owned(e.to_string()))?;
            <Self as pbrs::Parse>::parse(&b)
        }
    }
    pbrs::impl_typed_message!(NestedMessage, NestedMessageView, NestedMessageMut);
    pub mod enum_only_proto3 {
        pub use super::Bool;
    }
    pub mod test_all_types_proto3 {
        pub use super::AliasedEnum;
        pub use super::NestedEnum;
        pub use super::NestedMessage;
    }
}
#[allow(unused_imports, reason = "generated by protoc-gen-pbrs")]
pub use __gen::*;