From 28b492ca995687ea7e5809ec2d8d691ec90738fd Mon Sep 17 00:00:00 2001
From: Pantani <danpantani@gmail.com>
Date: Mon, 22 Sep 2025 18:41:50 -0300
Subject: [PATCH 1/9] feat: fixed commision rate and max rate parameter

---
 api/cosmos/staking/v1beta1/staking.pulsar.go |  267 ++-
 proto/cosmos/staking/v1beta1/staking.proto   |   12 +-
 x/staking/keeper/msg_server.go               |   30 +-
 x/staking/keeper/params.go                   |    6 +
 x/staking/simulation/genesis.go              |   19 +-
 x/staking/types/errors.go                    |    2 +
 x/staking/types/params.go                    |   83 +-
 x/staking/types/params_legacy.go             |    2 +
 x/staking/types/staking.pb.go                | 1871 +++++++++---------
 9 files changed, 1271 insertions(+), 1021 deletions(-)

diff --git a/api/cosmos/staking/v1beta1/staking.pulsar.go b/api/cosmos/staking/v1beta1/staking.pulsar.go
index 9ec8314f45ca..9ff18ca17bcb 100644
--- a/api/cosmos/staking/v1beta1/staking.pulsar.go
+++ b/api/cosmos/staking/v1beta1/staking.pulsar.go
@@ -9416,6 +9416,7 @@ var (
 	fd_Params_historical_entries  protoreflect.FieldDescriptor
 	fd_Params_bond_denom          protoreflect.FieldDescriptor
 	fd_Params_min_commission_rate protoreflect.FieldDescriptor
+	fd_Params_max_commission_rate protoreflect.FieldDescriptor
 )
 
 func init() {
@@ -9427,6 +9428,7 @@ func init() {
 	fd_Params_historical_entries = md_Params.Fields().ByName("historical_entries")
 	fd_Params_bond_denom = md_Params.Fields().ByName("bond_denom")
 	fd_Params_min_commission_rate = md_Params.Fields().ByName("min_commission_rate")
+	fd_Params_max_commission_rate = md_Params.Fields().ByName("max_commission_rate")
 }
 
 var _ protoreflect.Message = (*fastReflection_Params)(nil)
@@ -9530,6 +9532,12 @@ func (x *fastReflection_Params) Range(f func(protoreflect.FieldDescriptor, proto
 			return
 		}
 	}
+	if x.MaxCommissionRate != "" {
+		value := protoreflect.ValueOfString(x.MaxCommissionRate)
+		if !f(fd_Params_max_commission_rate, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -9557,6 +9565,8 @@ func (x *fastReflection_Params) Has(fd protoreflect.FieldDescriptor) bool {
 		return x.BondDenom != ""
 	case "cosmos.staking.v1beta1.Params.min_commission_rate":
 		return x.MinCommissionRate != ""
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		return x.MaxCommissionRate != ""
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
@@ -9585,6 +9595,8 @@ func (x *fastReflection_Params) Clear(fd protoreflect.FieldDescriptor) {
 		x.BondDenom = ""
 	case "cosmos.staking.v1beta1.Params.min_commission_rate":
 		x.MinCommissionRate = ""
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		x.MaxCommissionRate = ""
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
@@ -9619,6 +9631,9 @@ func (x *fastReflection_Params) Get(descriptor protoreflect.FieldDescriptor) pro
 	case "cosmos.staking.v1beta1.Params.min_commission_rate":
 		value := x.MinCommissionRate
 		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		value := x.MaxCommissionRate
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
@@ -9651,6 +9666,8 @@ func (x *fastReflection_Params) Set(fd protoreflect.FieldDescriptor, value proto
 		x.BondDenom = value.Interface().(string)
 	case "cosmos.staking.v1beta1.Params.min_commission_rate":
 		x.MinCommissionRate = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		x.MaxCommissionRate = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
@@ -9686,6 +9703,8 @@ func (x *fastReflection_Params) Mutable(fd protoreflect.FieldDescriptor) protore
 		panic(fmt.Errorf("field bond_denom of message cosmos.staking.v1beta1.Params is not mutable"))
 	case "cosmos.staking.v1beta1.Params.min_commission_rate":
 		panic(fmt.Errorf("field min_commission_rate of message cosmos.staking.v1beta1.Params is not mutable"))
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		panic(fmt.Errorf("field max_commission_rate of message cosmos.staking.v1beta1.Params is not mutable"))
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
@@ -9712,6 +9731,8 @@ func (x *fastReflection_Params) NewField(fd protoreflect.FieldDescriptor) protor
 		return protoreflect.ValueOfString("")
 	case "cosmos.staking.v1beta1.Params.min_commission_rate":
 		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
@@ -9802,6 +9823,10 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
+		l = len(x.MaxCommissionRate)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -9831,6 +9856,13 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.MaxCommissionRate) > 0 {
+			i -= len(x.MaxCommissionRate)
+			copy(dAtA[i:], x.MaxCommissionRate)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MaxCommissionRate)))
+			i--
+			dAtA[i] = 0x3a
+		}
 		if len(x.MinCommissionRate) > 0 {
 			i -= len(x.MinCommissionRate)
 			copy(dAtA[i:], x.MinCommissionRate)
@@ -10080,6 +10112,38 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 				}
 				x.MinCommissionRate = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
+			case 7:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaxCommissionRate", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.MaxCommissionRate = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -13745,8 +13809,10 @@ type Params struct {
 	HistoricalEntries uint32 `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty"`
 	// bond_denom defines the bondable coin denomination.
 	BondDenom string `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty"`
-	// min_commission_rate is the chain-wide minimum commission rate that a validator can charge their delegators
+	// min_commission_rate represents the minimum commission rate that a validator can charge their delegators
 	MinCommissionRate string `protobuf:"bytes,6,opt,name=min_commission_rate,json=minCommissionRate,proto3" json:"min_commission_rate,omitempty"`
+	// max_commission_rate represents the maximum commission rate that a validator can charge their delegators
+	MaxCommissionRate string `protobuf:"bytes,7,opt,name=max_commission_rate,json=maxCommissionRate,proto3" json:"max_commission_rate,omitempty"`
 }
 
 func (x *Params) Reset() {
@@ -13811,6 +13877,13 @@ func (x *Params) GetMinCommissionRate() string {
 	return ""
 }
 
+func (x *Params) GetMaxCommissionRate() string {
+	if x != nil {
+		return x.MaxCommissionRate
+	}
+	return ""
+}
+
 // DelegationResponse is equivalent to Delegation except that it contains a
 // balance in addition to shares which is more suitable for client responses.
 type DelegationResponse struct {
@@ -14308,7 +14381,7 @@ var file_cosmos_staking_v1beta1_staking_proto_rawDesc = []byte{
 	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
 	0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8,
 	0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3a, 0x08, 0x88,
-	0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x9c, 0x03, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61,
+	0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xa3, 0x04, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61,
 	0x6d, 0x73, 0x12, 0x4f, 0x0a, 0x0e, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f,
 	0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f,
 	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72,
@@ -14332,98 +14405,106 @@ var file_cosmos_staking_v1beta1_staking_proto_rawDesc = []byte{
 	0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x22, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f,
 	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x44, 0x65, 0x63, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x11, 0x6d,
 	0x69, 0x6e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65,
-	0x3a, 0x24, 0xe8, 0xa0, 0x1f, 0x01, 0x8a, 0xe7, 0xb0, 0x2a, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
-	0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x78, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f,
-	0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0xa9, 0x01, 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x67,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4d, 0x0a,
-	0x0a, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x22, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69,
-	0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x67,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01,
-	0x52, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x07,
-	0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e,
-	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65,
-	0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7,
-	0xb0, 0x2a, 0x01, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x3a, 0x04, 0xe8, 0xa0,
-	0x1f, 0x00, 0x22, 0xcd, 0x01, 0x0a, 0x19, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x63, 0x0a, 0x12, 0x72, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x5f, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x63,
+	0x12, 0x84, 0x01, 0x0a, 0x13, 0x6d, 0x61, 0x78, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73,
+	0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x42, 0x54,
+	0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64,
+	0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79,
+	0x44, 0x65, 0x63, 0xf2, 0xde, 0x1f, 0x1a, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x6d, 0x61, 0x78,
+	0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65,
+	0x22, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x44, 0x65, 0x63, 0xa8,
+	0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x11, 0x6d, 0x61, 0x78, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73,
+	0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x3a, 0x24, 0xe8, 0xa0, 0x1f, 0x01, 0x8a, 0xe7, 0xb0,
+	0x2a, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x78, 0x2f, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0xa9, 0x01,
+	0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4d, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde,
+	0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61,
+	0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42,
+	0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61,
+	0x6e, 0x63, 0x65, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xcd, 0x01, 0x0a, 0x19, 0x52, 0x65,
+	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x63, 0x0a, 0x12, 0x72, 0x65, 0x64, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x52, 0x65, 0x64,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x09,
+	0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x11, 0x72, 0x65, 0x64, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x45, 0x0a, 0x07,
+	0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2b, 0xc8,
+	0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b,
+	0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0a,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61,
+	0x6e, 0x63, 0x65, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xc9, 0x01, 0x0a, 0x14, 0x52, 0x65,
+	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x53, 0x0a, 0x0c, 0x72, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09,
+	0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0c, 0x72, 0x65, 0x64, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x56, 0x0a, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69,
+	0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x09, 0xc8, 0xde, 0x1f,
+	0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3a,
+	0x04, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xeb, 0x01, 0x0a, 0x04, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x71,
+	0x0a, 0x11, 0x6e, 0x6f, 0x74, 0x5f, 0x62, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b,
+	0x65, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x45, 0xc8, 0xde, 0x1f, 0x00, 0xda,
+	0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f,
+	0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xea, 0xde, 0x1f, 0x11, 0x6e, 0x6f, 0x74, 0x5f,
+	0x62, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0xd2, 0xb4, 0x2d,
+	0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0xa8, 0xe7, 0xb0, 0x2a, 0x01,
+	0x52, 0x0f, 0x6e, 0x6f, 0x74, 0x42, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
+	0x73, 0x12, 0x66, 0x0a, 0x0d, 0x62, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65,
+	0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x41, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde,
+	0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d,
+	0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xea, 0xde, 0x1f, 0x0d, 0x62, 0x6f, 0x6e, 0x64, 0x65,
+	0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0c, 0x62, 0x6f, 0x6e,
+	0x64, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x3a, 0x08, 0xe8, 0xa0, 0x1f, 0x01, 0xf0,
+	0xa0, 0x1f, 0x01, 0x22, 0x59, 0x0a, 0x10, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x12, 0x45, 0x0a, 0x07, 0x75, 0x70, 0x64, 0x61, 0x74,
+	0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x65, 0x6e, 0x64, 0x65,
+	0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x61, 0x62, 0x63, 0x69, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00,
+	0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x2a, 0xb6,
+	0x01, 0x0a, 0x0a, 0x42, 0x6f, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2c, 0x0a,
+	0x17, 0x42, 0x4f, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53,
+	0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x1a, 0x0f, 0x8a, 0x9d, 0x20, 0x0b,
+	0x55, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x12, 0x26, 0x0a, 0x14, 0x42,
+	0x4f, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x42, 0x4f, 0x4e,
+	0x44, 0x45, 0x44, 0x10, 0x01, 0x1a, 0x0c, 0x8a, 0x9d, 0x20, 0x08, 0x55, 0x6e, 0x62, 0x6f, 0x6e,
+	0x64, 0x65, 0x64, 0x12, 0x28, 0x0a, 0x15, 0x42, 0x4f, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54,
+	0x55, 0x53, 0x5f, 0x55, 0x4e, 0x42, 0x4f, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x1a, 0x0d,
+	0x8a, 0x9d, 0x20, 0x09, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x22, 0x0a,
+	0x12, 0x42, 0x4f, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x42, 0x4f, 0x4e,
+	0x44, 0x45, 0x44, 0x10, 0x03, 0x1a, 0x0a, 0x8a, 0x9d, 0x20, 0x06, 0x42, 0x6f, 0x6e, 0x64, 0x65,
+	0x64, 0x1a, 0x04, 0x88, 0xa3, 0x1e, 0x00, 0x2a, 0x5d, 0x0a, 0x0a, 0x49, 0x6e, 0x66, 0x72, 0x61,
+	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x16, 0x49, 0x4e, 0x46, 0x52, 0x41, 0x43, 0x54,
+	0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10,
+	0x00, 0x12, 0x1a, 0x0a, 0x16, 0x49, 0x4e, 0x46, 0x52, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f,
+	0x44, 0x4f, 0x55, 0x42, 0x4c, 0x45, 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x10, 0x01, 0x12, 0x17, 0x0a,
+	0x13, 0x49, 0x4e, 0x46, 0x52, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x4f, 0x57, 0x4e,
+	0x54, 0x49, 0x4d, 0x45, 0x10, 0x02, 0x42, 0xdc, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x63,
 	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31,
-	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0,
-	0x2a, 0x01, 0x52, 0x11, 0x72, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x45, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65,
-	0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2b, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x15,
-	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74,
-	0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
-	0x49, 0x6e, 0x74, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x3a, 0x04, 0xe8, 0xa0,
-	0x1f, 0x01, 0x22, 0xc9, 0x01, 0x0a, 0x14, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x0c, 0x72,
-	0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x24, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69,
-	0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x52, 0x65, 0x64, 0x65, 0x6c,
-	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0,
-	0x2a, 0x01, 0x52, 0x0c, 0x72, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x12, 0x56, 0x0a, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x31, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69,
-	0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x52, 0x65, 0x64, 0x65, 0x6c,
-	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52,
-	0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xeb,
-	0x01, 0x0a, 0x04, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x71, 0x0a, 0x11, 0x6e, 0x6f, 0x74, 0x5f, 0x62,
-	0x6f, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x42, 0x45, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d,
-	0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e,
-	0x74, 0xea, 0xde, 0x1f, 0x11, 0x6e, 0x6f, 0x74, 0x5f, 0x62, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x5f,
-	0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
-	0x2e, 0x49, 0x6e, 0x74, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0f, 0x6e, 0x6f, 0x74, 0x42, 0x6f,
-	0x6e, 0x64, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x66, 0x0a, 0x0d, 0x62, 0x6f,
-	0x6e, 0x64, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x09, 0x42, 0x41, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
-	0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74,
-	0xea, 0xde, 0x1f, 0x0d, 0x62, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e,
-	0x73, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0xa8,
-	0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0c, 0x62, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65,
-	0x6e, 0x73, 0x3a, 0x08, 0xe8, 0xa0, 0x1f, 0x01, 0xf0, 0xa0, 0x1f, 0x01, 0x22, 0x59, 0x0a, 0x10,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73,
-	0x12, 0x45, 0x0a, 0x07, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x20, 0x2e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x61,
-	0x62, 0x63, 0x69, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x70, 0x64,
-	0x61, 0x74, 0x65, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07,
-	0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x2a, 0xb6, 0x01, 0x0a, 0x0a, 0x42, 0x6f, 0x6e, 0x64,
-	0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2c, 0x0a, 0x17, 0x42, 0x4f, 0x4e, 0x44, 0x5f, 0x53,
-	0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45,
-	0x44, 0x10, 0x00, 0x1a, 0x0f, 0x8a, 0x9d, 0x20, 0x0b, 0x55, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69,
-	0x66, 0x69, 0x65, 0x64, 0x12, 0x26, 0x0a, 0x14, 0x42, 0x4f, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41,
-	0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x42, 0x4f, 0x4e, 0x44, 0x45, 0x44, 0x10, 0x01, 0x1a, 0x0c,
-	0x8a, 0x9d, 0x20, 0x08, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x12, 0x28, 0x0a, 0x15,
-	0x42, 0x4f, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x42, 0x4f,
-	0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x1a, 0x0d, 0x8a, 0x9d, 0x20, 0x09, 0x55, 0x6e, 0x62,
-	0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x22, 0x0a, 0x12, 0x42, 0x4f, 0x4e, 0x44, 0x5f, 0x53,
-	0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x42, 0x4f, 0x4e, 0x44, 0x45, 0x44, 0x10, 0x03, 0x1a, 0x0a,
-	0x8a, 0x9d, 0x20, 0x06, 0x42, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x1a, 0x04, 0x88, 0xa3, 0x1e, 0x00,
-	0x2a, 0x5d, 0x0a, 0x0a, 0x49, 0x6e, 0x66, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a,
-	0x0a, 0x16, 0x49, 0x4e, 0x46, 0x52, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x53,
-	0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x49, 0x4e,
-	0x46, 0x52, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x4f, 0x55, 0x42, 0x4c, 0x45, 0x5f,
-	0x53, 0x49, 0x47, 0x4e, 0x10, 0x01, 0x12, 0x17, 0x0a, 0x13, 0x49, 0x4e, 0x46, 0x52, 0x41, 0x43,
-	0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x4f, 0x57, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x10, 0x02, 0x42,
-	0xdc, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73,
-	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x42, 0x0c,
-	0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x36,
-	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69,
-	0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f,
-	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x76,
-	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x53, 0x58, 0xaa, 0x02, 0x16, 0x43,
-	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x56, 0x31,
-	0x62, 0x65, 0x74, 0x61, 0x31, 0xca, 0x02, 0x16, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53,
-	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02,
-	0x22, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x5c,
-	0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64,
-	0x61, 0x74, 0x61, 0xea, 0x02, 0x18, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x53, 0x74,
-	0x61, 0x6b, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x62, 0x06,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x42, 0x0c, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x36, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b,
+	0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03,
+	0x43, 0x53, 0x58, 0xaa, 0x02, 0x16, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x53, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, 0x02, 0x16, 0x43,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, 0x22, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47,
+	0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x18, 0x43, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
diff --git a/proto/cosmos/staking/v1beta1/staking.proto b/proto/cosmos/staking/v1beta1/staking.proto
index 24ec65d10202..684d3c93de3c 100644
--- a/proto/cosmos/staking/v1beta1/staking.proto
+++ b/proto/cosmos/staking/v1beta1/staking.proto
@@ -312,7 +312,8 @@ message Params {
   uint32 historical_entries = 4;
   // bond_denom defines the bondable coin denomination.
   string bond_denom = 5;
-  // min_commission_rate is the chain-wide minimum commission rate that a validator can charge their delegators
+
+  // min_commission_rate represents the minimum commission rate that a validator can charge their delegators
   string min_commission_rate = 6 [
     (gogoproto.moretags)   = "yaml:\"min_commission_rate\"",
     (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
@@ -320,6 +321,15 @@ message Params {
     (amino.dont_omitempty) = true,
     (cosmos_proto.scalar)  = "cosmos.Dec"
   ];
+
+  // max_commission_rate represents the maximum commission rate that a validator can charge their delegators
+  string max_commission_rate = 7 [
+    (gogoproto.moretags)   = "yaml:\"max_commission_rate\"",
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
+    (gogoproto.nullable)   = false,
+    (amino.dont_omitempty) = true,
+    (cosmos_proto.scalar)  = "cosmos.Dec"
+  ];
 }
 
 // DelegationResponse is equivalent to Delegation except that it contains a
diff --git a/x/staking/keeper/msg_server.go b/x/staking/keeper/msg_server.go
index 19b7ba7a2593..a89bd7a2e8e7 100644
--- a/x/staking/keeper/msg_server.go
+++ b/x/staking/keeper/msg_server.go
@@ -48,8 +48,21 @@ func (k msgServer) CreateValidator(ctx context.Context, msg *types.MsgCreateVali
 		return nil, err
 	}
 
+	maxCommRate, err := k.MaxCommissionRate(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if maxCommRate.Equal(minCommRate) && !msg.Commission.Rate.Equal(minCommRate) {
+		return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate must be equal too", minCommRate.String())
+	}
+
 	if msg.Commission.Rate.LT(minCommRate) {
-		return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "cannot set validator commission to less than minimum rate of %s", minCommRate)
+		return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "cannot set validator commission to less than minimum rate of %s", minCommRate.String())
+	}
+
+	if msg.Commission.Rate.GT(maxCommRate) {
+		return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator commission to more than minimum rate of %s", maxCommRate.String())
 	}
 
 	// check to see if the pubkey or sender has been registered before
@@ -184,8 +197,21 @@ func (k msgServer) EditValidator(ctx context.Context, msg *types.MsgEditValidato
 			return nil, errorsmod.Wrap(sdkerrors.ErrLogic, err.Error())
 		}
 
+		maxCommissionRate, err := k.MaxCommissionRate(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		if maxCommissionRate.Equal(minCommissionRate) && !msg.CommissionRate.Equal(minCommissionRate) {
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate must be equal too", minCommissionRate.String())
+		}
+
 		if msg.CommissionRate.LT(minCommissionRate) {
-			return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "commission rate cannot be less than the min commission rate %s", minCommissionRate.String())
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "commission rate cannot be less than the min commission rate %s", minCommissionRate.String())
+		}
+
+		if msg.CommissionRate.GT(maxCommissionRate) {
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator commission to more than minimum rate of %s", maxCommissionRate.String())
 		}
 	}
 
diff --git a/x/staking/keeper/params.go b/x/staking/keeper/params.go
index 14b07747d881..156e0609ac3b 100644
--- a/x/staking/keeper/params.go
+++ b/x/staking/keeper/params.go
@@ -56,6 +56,12 @@ func (k Keeper) MinCommissionRate(ctx context.Context) (math.LegacyDec, error) {
 	return params.MinCommissionRate, err
 }
 
+// MaxCommissionRate - Maximum validator commission rate
+func (k Keeper) MaxCommissionRate(ctx context.Context) (math.LegacyDec, error) {
+	params, err := k.GetParams(ctx)
+	return params.MaxCommissionRate, err
+}
+
 // SetParams sets the x/staking module parameters.
 // CONTRACT: This method performs no validation of the parameters.
 func (k Keeper) SetParams(ctx context.Context, params types.Params) error {
diff --git a/x/staking/simulation/genesis.go b/x/staking/simulation/genesis.go
index 08cc7dd05c20..51faef8a1c70 100644
--- a/x/staking/simulation/genesis.go
+++ b/x/staking/simulation/genesis.go
@@ -16,9 +16,10 @@ import (
 
 // Simulation parameter constants
 const (
-	unbondingTime     = "unbonding_time"
-	maxValidators     = "max_validators"
-	historicalEntries = "historical_entries"
+	unbondingTime         = "unbonding_time"
+	maxValidators         = "max_validators"
+	historicalEntries     = "historical_entries"
+	maximumCommissionRate = "max_commission_rate"
 )
 
 // genUnbondingTime returns randomized UnbondingTime
@@ -36,6 +37,11 @@ func getHistEntries(r *rand.Rand) uint32 {
 	return uint32(r.Intn(int(types.DefaultHistoricalEntries + 1)))
 }
 
+// getMaxCommissionRate returns randomized MaxCommissionRate between 0-100.
+func getMaxCommissionRate(r *rand.Rand) sdkmath.LegacyDec {
+	return sdkmath.LegacyNewDecWithPrec(int64(r.Intn(types.DefaultMaxCommission+1)), 2)
+}
+
 // RandomizedGenState generates a random GenesisState for staking
 func RandomizedGenState(simState *module.SimulationState) {
 	// params
@@ -44,6 +50,7 @@ func RandomizedGenState(simState *module.SimulationState) {
 		maxVals           uint32
 		histEntries       uint32
 		minCommissionRate sdkmath.LegacyDec
+		maxCommissionRate sdkmath.LegacyDec
 	)
 
 	simState.AppParams.GetOrGenerate(unbondingTime, &unbondTime, simState.Rand, func(r *rand.Rand) { unbondTime = genUnbondingTime(r) })
@@ -52,10 +59,12 @@ func RandomizedGenState(simState *module.SimulationState) {
 
 	simState.AppParams.GetOrGenerate(historicalEntries, &histEntries, simState.Rand, func(r *rand.Rand) { histEntries = getHistEntries(r) })
 
+	simState.AppParams.GetOrGenerate(maximumCommissionRate, &histEntries, simState.Rand, func(r *rand.Rand) { maxCommissionRate = getMaxCommissionRate(r) })
+
 	// NOTE: the slashing module need to be defined after the staking module on the
 	// NewSimulationManager constructor for this to work
 	simState.UnbondTime = unbondTime
-	params := types.NewParams(simState.UnbondTime, maxVals, 7, histEntries, simState.BondDenom, minCommissionRate)
+	params := types.NewParams(simState.UnbondTime, maxVals, 7, histEntries, simState.BondDenom, minCommissionRate, maxCommissionRate)
 
 	// validators & delegations
 	var (
@@ -69,7 +78,7 @@ func RandomizedGenState(simState *module.SimulationState) {
 		valAddr := sdk.ValAddress(simState.Accounts[i].Address)
 		valAddrs[i] = valAddr
 
-		maxCommission := sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(simState.Rand, 1, 100)), 2)
+		maxCommission := sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(simState.Rand, types.DefaultMinCommission, types.DefaultMaxCommission)), 2)
 		commission := types.NewCommission(
 			simulation.RandomDecAmount(simState.Rand, maxCommission),
 			maxCommission,
diff --git a/x/staking/types/errors.go b/x/staking/types/errors.go
index 00441564352a..bfe030fc8fb0 100644
--- a/x/staking/types/errors.go
+++ b/x/staking/types/errors.go
@@ -48,4 +48,6 @@ var (
 	ErrInvalidSigner                   = errors.Register(ModuleName, 43, "expected authority account as only signer for proposal message")
 	ErrBadRedelegationSrc              = errors.Register(ModuleName, 44, "redelegation source validator not found")
 	ErrNoUnbondingType                 = errors.Register(ModuleName, 45, "unbonding type not found")
+	ErrCommissionLTMaxRate             = errors.Register(ModuleName, 46, "commission cannot be less than min rate")
+	ErrCommissionLTRateNotEqual        = errors.Register(ModuleName, 47, "commission cannot be different if than min and max rate are equal")
 )
diff --git a/x/staking/types/params.go b/x/staking/types/params.go
index 9687b206485c..e17c81aeb9ee 100644
--- a/x/staking/types/params.go
+++ b/x/staking/types/params.go
@@ -19,23 +19,35 @@ const (
 	// TODO: Justify our choice of default here.
 	DefaultUnbondingTime time.Duration = time.Hour * 24 * 7 * 3
 
-	// Default maximum number of bonded validators
+	// DefaultMaxValidators default maximum number of bonded validators
 	DefaultMaxValidators uint32 = 100
 
-	// Default maximum entries in a UBD/RED pair
+	// DefaultMaxEntries default maximum entries in a UBD/RED pair
 	DefaultMaxEntries uint32 = 7
 
-	// DefaultHistorical entries is 10000. Apps that don't use IBC can ignore this
+	// DefaultHistoricalEntries default historical entries is 10000. Apps that don't use IBC can ignore this
 	// value by not adding the staking module to the application module manager's
 	// SetOrderBeginBlockers.
 	DefaultHistoricalEntries uint32 = 10000
+
+	// DefaultMinCommission default minimum commission.
+	// SetOrderBeginBlockers.
+	DefaultMinCommission = 1
+
+	// DefaultMaxCommission default maximum commission.
+	DefaultMaxCommission = 100 // 30% (30/100 = 0.3 = 30%
 )
 
-// DefaultMinCommissionRate is set to 0%
-var DefaultMinCommissionRate = math.LegacyZeroDec()
+var (
+	// DefaultMinCommissionRate is set to 0%
+	DefaultMinCommissionRate = math.LegacyNewDecWithPrec(DefaultMinCommission, 2)
+
+	// DefaultMaxCommissionRate is set to 0%
+	DefaultMaxCommissionRate = math.LegacyNewDecWithPrec(DefaultMaxCommission, 2)
+)
 
 // NewParams creates a new Params instance
-func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historicalEntries uint32, bondDenom string, minCommissionRate math.LegacyDec) Params {
+func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historicalEntries uint32, bondDenom string, minCommissionRate, maxCommissionRate math.LegacyDec) Params {
 	return Params{
 		UnbondingTime:     unbondingTime,
 		MaxValidators:     maxValidators,
@@ -43,6 +55,7 @@ func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historica
 		HistoricalEntries: historicalEntries,
 		BondDenom:         bondDenom,
 		MinCommissionRate: minCommissionRate,
+		MaxCommissionRate: maxCommissionRate,
 	}
 }
 
@@ -55,10 +68,11 @@ func DefaultParams() Params {
 		DefaultHistoricalEntries,
 		sdk.DefaultBondDenom,
 		DefaultMinCommissionRate,
+		DefaultMaxCommissionRate,
 	)
 }
 
-// unmarshal the current staking params value from store key or panic
+// MustUnmarshalParams unmarshal the current staking params value from store key or panic
 func MustUnmarshalParams(cdc *codec.LegacyAmino, value []byte) Params {
 	params, err := UnmarshalParams(cdc, value)
 	if err != nil {
@@ -68,7 +82,7 @@ func MustUnmarshalParams(cdc *codec.LegacyAmino, value []byte) Params {
 	return params
 }
 
-// unmarshal the current staking params value from store key
+// UnmarshalParams unmarshal the current staking params value from store key
 func UnmarshalParams(cdc *codec.LegacyAmino, value []byte) (params Params, err error) {
 	err = cdc.Unmarshal(value, &params)
 	if err != nil {
@@ -78,7 +92,7 @@ func UnmarshalParams(cdc *codec.LegacyAmino, value []byte) (params Params, err e
 	return
 }
 
-// validate a set of params
+// Validate validates a set of params
 func (p Params) Validate() error {
 	if err := validateUnbondingTime(p.UnbondingTime); err != nil {
 		return err
@@ -96,11 +110,11 @@ func (p Params) Validate() error {
 		return err
 	}
 
-	if err := validateMinCommissionRate(p.MinCommissionRate); err != nil {
+	if err := validateHistoricalEntries(p.HistoricalEntries); err != nil {
 		return err
 	}
 
-	if err := validateHistoricalEntries(p.HistoricalEntries); err != nil {
+	if err := validateCommissionRate(p.MinCommissionRate, p.MaxCommissionRate); err != nil {
 		return err
 	}
 
@@ -188,7 +202,26 @@ func ValidatePowerReduction(i interface{}) error {
 func validateMinCommissionRate(i interface{}) error {
 	v, ok := i.(math.LegacyDec)
 	if !ok {
-		return fmt.Errorf("invalid parameter type: %T", i)
+		return fmt.Errorf("invalid minimum parameter type: %T", i)
+	}
+
+	if v.IsNil() {
+		return fmt.Errorf("minimum commission rate cannot be nil: %s", v)
+	}
+	if v.IsNegative() {
+		return fmt.Errorf("minimum commission rate cannot be negative: %s", v)
+	}
+	if v.GT(math.LegacyOneDec()) {
+		return fmt.Errorf("minimum commission rate cannot be greater than 100%%: %s", v)
+	}
+
+	return nil
+}
+
+func validateMaxCommissionRate(i interface{}) error {
+	v, ok := i.(math.LegacyDec)
+	if !ok {
+		return fmt.Errorf("invalid maximum parameter type: %T", i)
 	}
 
 	if v.IsNil() {
@@ -203,3 +236,29 @@ func validateMinCommissionRate(i interface{}) error {
 
 	return nil
 }
+
+func validateCommissionRate(minimum, maximum interface{}) error {
+	if err := validateMinCommissionRate(minimum); err != nil {
+		return err
+	}
+
+	if err := validateMaxCommissionRate(maximum); err != nil {
+		return err
+	}
+
+	vMin, ok := minimum.(math.LegacyDec)
+	if !ok {
+		return fmt.Errorf("invalid minimum parameter type: %T", minimum)
+	}
+
+	vMax, ok := maximum.(math.LegacyDec)
+	if !ok {
+		return fmt.Errorf("invalid maximum parameter type: %T", maximum)
+	}
+
+	if vMin.GT(vMax) {
+		return fmt.Errorf("minimum commission (%s) rate cannot be greater than the maximum (%s)", vMin.String(), vMax.String())
+	}
+
+	return nil
+}
diff --git a/x/staking/types/params_legacy.go b/x/staking/types/params_legacy.go
index f2ab55624976..09baa205eb6e 100644
--- a/x/staking/types/params_legacy.go
+++ b/x/staking/types/params_legacy.go
@@ -9,6 +9,7 @@ var (
 	KeyBondDenom         = []byte("BondDenom")
 	KeyHistoricalEntries = []byte("HistoricalEntries")
 	KeyMinCommissionRate = []byte("MinCommissionRate")
+	KeyMaxCommissionRate = []byte("MaxCommissionRate")
 )
 
 var _ paramtypes.ParamSet = (*Params)(nil)
@@ -28,5 +29,6 @@ func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
 		paramtypes.NewParamSetPair(KeyHistoricalEntries, &p.HistoricalEntries, validateHistoricalEntries),
 		paramtypes.NewParamSetPair(KeyBondDenom, &p.BondDenom, validateBondDenom),
 		paramtypes.NewParamSetPair(KeyMinCommissionRate, &p.MinCommissionRate, validateMinCommissionRate),
+		paramtypes.NewParamSetPair(KeyMaxCommissionRate, &p.MaxCommissionRate, validateMaxCommissionRate),
 	}
 }
diff --git a/x/staking/types/staking.pb.go b/x/staking/types/staking.pb.go
index b03a9d35cf50..1a9a8e787a6b 100644
--- a/x/staking/types/staking.pb.go
+++ b/x/staking/types/staking.pb.go
@@ -930,8 +930,10 @@ type Params struct {
 	HistoricalEntries uint32 `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty"`
 	// bond_denom defines the bondable coin denomination.
 	BondDenom string `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty"`
-	// min_commission_rate is the chain-wide minimum commission rate that a validator can charge their delegators
+	// min_commission_rate represents the minimum commission rate that a validator can charge their delegators
 	MinCommissionRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,6,opt,name=min_commission_rate,json=minCommissionRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"min_commission_rate" yaml:"min_commission_rate"`
+	// max_commission_rate represents the maximum commission rate that a validator can charge their delegators
+	MaxCommissionRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,7,opt,name=max_commission_rate,json=maxCommissionRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"max_commission_rate" yaml:"max_commission_rate"`
 }
 
 func (m *Params) Reset()         { *m = Params{} }
@@ -1276,126 +1278,128 @@ func init() {
 }
 
 var fileDescriptor_64c30c6cf92913c9 = []byte{
-	// 1901 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0x4d, 0x6c, 0x63, 0x47,
-	0x1d, 0xcf, 0x8b, 0x53, 0x27, 0xf9, 0x3b, 0x89, 0x9d, 0xd9, 0x2f, 0xaf, 0x97, 0xc6, 0x5e, 0x77,
-	0xa1, 0xe9, 0xd2, 0xd8, 0x6c, 0x90, 0x7a, 0x08, 0x08, 0x14, 0xc7, 0xde, 0xae, 0x4b, 0x9b, 0x04,
-	0x3b, 0x09, 0x94, 0xaf, 0xa7, 0xf1, 0x7b, 0x13, 0x67, 0x88, 0x3d, 0xcf, 0xbc, 0x19, 0x2f, 0xf1,
-	0x9d, 0x43, 0x15, 0x84, 0x54, 0x09, 0x09, 0x21, 0xc1, 0x8a, 0x95, 0xb8, 0x94, 0x5b, 0x0f, 0x2b,
-	0xee, 0xdc, 0x0a, 0x12, 0xd2, 0x6a, 0x4f, 0x08, 0x89, 0x80, 0x76, 0x0f, 0xad, 0xe0, 0x82, 0x38,
-	0x71, 0x44, 0xf3, 0xf1, 0x3e, 0x1c, 0x27, 0x9b, 0xcd, 0xb6, 0x42, 0x15, 0x5c, 0x9e, 0xde, 0xcc,
-	0xfc, 0xff, 0xbf, 0x99, 0xff, 0xef, 0xff, 0x31, 0x1f, 0x70, 0xc3, 0xf1, 0x78, 0xd7, 0xe3, 0x65,
-	0x2e, 0xf0, 0x3e, 0x65, 0xed, 0xf2, 0xdd, 0x5b, 0x2d, 0x22, 0xf0, 0xad, 0xa0, 0x5d, 0xea, 0xf9,
-	0x9e, 0xf0, 0xd0, 0x65, 0x2d, 0x55, 0x0a, 0x7a, 0x8d, 0x54, 0xee, 0x62, 0xdb, 0x6b, 0x7b, 0x4a,
-	0xa4, 0x2c, 0xff, 0xb4, 0x74, 0xee, 0x6a, 0xdb, 0xf3, 0xda, 0x1d, 0x52, 0x56, 0xad, 0x56, 0x7f,
-	0xb7, 0x8c, 0xd9, 0xc0, 0x0c, 0x2d, 0x1c, 0x1f, 0x72, 0xfb, 0x3e, 0x16, 0xd4, 0x63, 0x66, 0x3c,
-	0x7f, 0x7c, 0x5c, 0xd0, 0x2e, 0xe1, 0x02, 0x77, 0x7b, 0x01, 0xb6, 0x5e, 0x89, 0xad, 0x27, 0x35,
-	0xcb, 0x32, 0xd8, 0xc6, 0x94, 0x16, 0xe6, 0x24, 0xb4, 0xc3, 0xf1, 0x68, 0x80, 0x3d, 0x8f, 0xbb,
-	0x94, 0x79, 0x65, 0xf5, 0x35, 0x5d, 0x9f, 0x11, 0x84, 0xb9, 0xc4, 0xef, 0x52, 0x26, 0xca, 0x62,
-	0xd0, 0x23, 0x5c, 0x7f, 0xcd, 0xe8, 0xb5, 0xd8, 0x28, 0x6e, 0x39, 0x34, 0x3e, 0x58, 0xfc, 0xa9,
-	0x05, 0x73, 0x77, 0x28, 0x17, 0x9e, 0x4f, 0x1d, 0xdc, 0xa9, 0xb3, 0x5d, 0x0f, 0x7d, 0x09, 0x92,
-	0x7b, 0x04, 0xbb, 0xc4, 0xcf, 0x5a, 0x05, 0x6b, 0x31, 0xb5, 0x9c, 0x2d, 0x45, 0x00, 0x25, 0xad,
-	0x7b, 0x47, 0x8d, 0x57, 0xa6, 0x3f, 0x38, 0xca, 0x8f, 0xbd, 0xf7, 0xe1, 0xfb, 0x37, 0xad, 0x86,
-	0x51, 0x41, 0x55, 0x48, 0xde, 0xc5, 0x1d, 0x4e, 0x44, 0x76, 0xbc, 0x90, 0x58, 0x4c, 0x2d, 0x5f,
-	0x2f, 0x9d, 0xcc, 0x79, 0x69, 0x07, 0x77, 0xa8, 0x8b, 0x85, 0x37, 0x8c, 0xa2, 0x75, 0x8b, 0x3f,
-	0x1b, 0x87, 0xf4, 0x9a, 0xd7, 0xed, 0x52, 0xce, 0xa9, 0xc7, 0x1a, 0x58, 0x10, 0x8e, 0xde, 0x80,
-	0x09, 0x1f, 0x0b, 0xa2, 0x16, 0x35, 0x5d, 0x79, 0x4d, 0x2a, 0xfd, 0xf9, 0x28, 0x7f, 0x4d, 0xc3,
-	0x73, 0x77, 0xbf, 0x44, 0xbd, 0x72, 0x17, 0x8b, 0xbd, 0xd2, 0x9b, 0xa4, 0x8d, 0x9d, 0x41, 0x95,
-	0x38, 0x8f, 0x1e, 0x2c, 0x81, 0x99, 0xbd, 0x4a, 0x1c, 0x3d, 0x83, 0xc2, 0x40, 0x5f, 0x87, 0xa9,
-	0x2e, 0x3e, 0xb0, 0x15, 0xde, 0xf8, 0xc7, 0xc2, 0x9b, 0xec, 0xe2, 0x03, 0xb9, 0x3e, 0xf4, 0x3d,
-	0x48, 0x4b, 0x48, 0x67, 0x0f, 0xb3, 0x36, 0xd1, 0xc8, 0x89, 0x8f, 0x85, 0x3c, 0xdb, 0xc5, 0x07,
-	0x6b, 0x0a, 0x4d, 0xe2, 0xaf, 0x4c, 0x7c, 0x74, 0x3f, 0x6f, 0x15, 0x7f, 0x67, 0x01, 0x44, 0xc4,
-	0x20, 0x0c, 0x19, 0x27, 0x6c, 0xa9, 0x49, 0xb9, 0x71, 0xda, 0xcb, 0xa7, 0xf1, 0x7e, 0x8c, 0xd6,
-	0xca, 0xac, 0x5c, 0xde, 0xc3, 0xa3, 0xbc, 0xa5, 0x67, 0x4d, 0x3b, 0x23, 0xb4, 0xa7, 0xfa, 0x3d,
-	0x17, 0x0b, 0x62, 0xcb, 0x18, 0x56, 0x6c, 0xa5, 0x96, 0x73, 0x25, 0x1d, 0xe0, 0xa5, 0x20, 0xc0,
-	0x4b, 0x5b, 0x41, 0x80, 0x6b, 0xc0, 0x77, 0xff, 0x1a, 0x00, 0x82, 0xd6, 0x96, 0xe3, 0xc6, 0x86,
-	0xf7, 0x2c, 0x48, 0x55, 0x09, 0x77, 0x7c, 0xda, 0x93, 0x29, 0x83, 0xb2, 0x30, 0xd9, 0xf5, 0x18,
-	0xdd, 0x37, 0x01, 0x37, 0xdd, 0x08, 0x9a, 0x28, 0x07, 0x53, 0xd4, 0x25, 0x4c, 0x50, 0x31, 0xd0,
-	0x6e, 0x6a, 0x84, 0x6d, 0xa9, 0xf5, 0x43, 0xd2, 0xe2, 0x34, 0xe0, 0xb9, 0x11, 0x34, 0xd1, 0x2b,
-	0x90, 0xe1, 0xc4, 0xe9, 0xfb, 0x54, 0x0c, 0x6c, 0xc7, 0x63, 0x02, 0x3b, 0x22, 0x3b, 0xa1, 0x44,
-	0xd2, 0x41, 0xff, 0x9a, 0xee, 0x96, 0x20, 0x2e, 0x11, 0x98, 0x76, 0x78, 0xf6, 0x05, 0x0d, 0x62,
-	0x9a, 0x66, 0xa9, 0x87, 0x93, 0x30, 0x1d, 0x06, 0x2a, 0x5a, 0x83, 0x8c, 0xd7, 0x23, 0xbe, 0xfc,
-	0xb7, 0xb1, 0xeb, 0xfa, 0x84, 0x73, 0x13, 0x8d, 0xd9, 0x47, 0x0f, 0x96, 0x2e, 0x1a, 0xc2, 0x57,
-	0xf5, 0x48, 0x53, 0xf8, 0x94, 0xb5, 0x1b, 0xe9, 0x40, 0xc3, 0x74, 0xa3, 0xb7, 0xa5, 0xcb, 0x18,
-	0x27, 0x8c, 0xf7, 0xb9, 0xdd, 0xeb, 0xb7, 0xf6, 0xc9, 0xc0, 0x90, 0x7a, 0x71, 0x84, 0xd4, 0x55,
-	0x36, 0xa8, 0x64, 0xff, 0x10, 0x41, 0x3b, 0xfe, 0xa0, 0x27, 0xbc, 0xd2, 0x66, 0xbf, 0xf5, 0x35,
-	0x32, 0x90, 0xae, 0x32, 0x38, 0x9b, 0x0a, 0x06, 0x5d, 0x86, 0xe4, 0xf7, 0x31, 0xed, 0x10, 0x57,
-	0x31, 0x32, 0xd5, 0x30, 0x2d, 0xb4, 0x02, 0x49, 0x2e, 0xb0, 0xe8, 0x73, 0x45, 0xc3, 0xdc, 0x72,
-	0xf1, 0xb4, 0xd8, 0xa8, 0x78, 0xcc, 0x6d, 0x2a, 0xc9, 0x86, 0xd1, 0x40, 0x6b, 0x90, 0x14, 0xde,
-	0x3e, 0x61, 0x86, 0xa0, 0xca, 0xe7, 0x4d, 0x34, 0x5f, 0x1a, 0x8d, 0xe6, 0x3a, 0x13, 0xb1, 0x38,
-	0xae, 0x33, 0xd1, 0x30, 0xaa, 0xe8, 0x3b, 0x90, 0x71, 0x49, 0x87, 0xb4, 0x15, 0x73, 0x7c, 0x0f,
-	0xfb, 0x84, 0x67, 0x93, 0x0a, 0xee, 0xd6, 0xb9, 0x93, 0xa3, 0x91, 0x0e, 0xa1, 0x9a, 0x0a, 0x09,
-	0x6d, 0x42, 0xca, 0x8d, 0xc2, 0x29, 0x3b, 0xa9, 0xc8, 0x7c, 0xe9, 0x34, 0x1b, 0x63, 0x91, 0x17,
-	0xaf, 0x3c, 0x71, 0x08, 0x19, 0x41, 0x7d, 0xd6, 0xf2, 0x98, 0x4b, 0x59, 0xdb, 0xde, 0x23, 0xb4,
-	0xbd, 0x27, 0xb2, 0x53, 0x05, 0x6b, 0x31, 0xd1, 0x48, 0x87, 0xfd, 0x77, 0x54, 0x37, 0xda, 0x84,
-	0xb9, 0x48, 0x54, 0x65, 0xc8, 0xf4, 0x79, 0x33, 0x64, 0x36, 0x04, 0x90, 0x22, 0xe8, 0x2d, 0x80,
-	0x28, 0x07, 0xb3, 0xa0, 0xd0, 0x8a, 0x67, 0x67, 0x73, 0xdc, 0x98, 0x18, 0x00, 0xfa, 0x36, 0x5c,
-	0xe8, 0x52, 0x66, 0x73, 0xd2, 0xd9, 0xb5, 0x0d, 0x73, 0x12, 0x37, 0x75, 0x7e, 0x6f, 0xce, 0x77,
-	0x29, 0x6b, 0x92, 0xce, 0x6e, 0x35, 0x44, 0x41, 0x5f, 0x86, 0x6b, 0x91, 0xf5, 0x1e, 0xb3, 0xf7,
-	0xbc, 0x8e, 0x6b, 0xfb, 0x64, 0xd7, 0x76, 0xbc, 0x3e, 0x13, 0xd9, 0x19, 0xc5, 0xd9, 0x95, 0x50,
-	0x64, 0x83, 0xdd, 0xf1, 0x3a, 0x6e, 0x83, 0xec, 0xae, 0xc9, 0x61, 0xf4, 0x12, 0x44, 0xa6, 0xdb,
-	0xd4, 0xe5, 0xd9, 0xd9, 0x42, 0x62, 0x71, 0xa2, 0x31, 0x13, 0x76, 0xd6, 0x5d, 0xbe, 0x32, 0xf5,
-	0xce, 0xfd, 0xfc, 0xd8, 0x47, 0xf7, 0xf3, 0x63, 0xc5, 0xdb, 0x30, 0xb3, 0x83, 0x3b, 0x26, 0x8f,
-	0x08, 0x47, 0xaf, 0xc1, 0x34, 0x0e, 0x1a, 0x59, 0xab, 0x90, 0x78, 0x6a, 0x1e, 0x46, 0xa2, 0xc5,
-	0xdf, 0x58, 0x90, 0xac, 0xee, 0x6c, 0x62, 0xea, 0xa3, 0x1a, 0xcc, 0x47, 0x81, 0xf9, 0xac, 0x29,
-	0x1d, 0xc5, 0x72, 0x90, 0xd3, 0xeb, 0x30, 0x7f, 0x37, 0xa8, 0x12, 0x21, 0x8c, 0xde, 0x57, 0xae,
-	0x3f, 0x7a, 0xb0, 0xf4, 0xa2, 0x81, 0x09, 0x2b, 0xc9, 0x31, 0xbc, 0xbb, 0xc7, 0xfa, 0x63, 0x36,
-	0xbf, 0x01, 0x93, 0x7a, 0xa9, 0x1c, 0x7d, 0x15, 0x5e, 0xe8, 0xc9, 0x1f, 0x65, 0x6a, 0x6a, 0x79,
-	0xe1, 0xd4, 0x00, 0x57, 0xf2, 0xf1, 0x70, 0xd0, 0x7a, 0xc5, 0x1f, 0x8f, 0x03, 0x54, 0x77, 0x76,
-	0xb6, 0x7c, 0xda, 0xeb, 0x10, 0xf1, 0x49, 0xd9, 0xbe, 0x0d, 0x97, 0x22, 0xdb, 0xb9, 0xef, 0x9c,
-	0xdf, 0xfe, 0x0b, 0xa1, 0x7e, 0xd3, 0x77, 0x4e, 0x84, 0x75, 0xb9, 0x08, 0x61, 0x13, 0xe7, 0x87,
-	0xad, 0x72, 0x31, 0xca, 0xec, 0x37, 0x21, 0x15, 0x91, 0xc1, 0x51, 0x1d, 0xa6, 0x84, 0xf9, 0x37,
-	0x04, 0x17, 0x4f, 0x27, 0x38, 0x50, 0x8b, 0x93, 0x1c, 0xaa, 0x17, 0xff, 0x6d, 0x01, 0xc4, 0x72,
-	0xe4, 0xd3, 0x19, 0x63, 0xa8, 0x0e, 0x49, 0x53, 0x89, 0x13, 0xcf, 0x5b, 0x89, 0x0d, 0x40, 0x8c,
-	0xd4, 0x9f, 0x8c, 0xc3, 0x85, 0xed, 0x20, 0x7b, 0x3f, 0xfd, 0x1c, 0x6c, 0xc3, 0x24, 0x61, 0xc2,
-	0xa7, 0x8a, 0x04, 0xe9, 0xf3, 0x2f, 0x9c, 0xe6, 0xf3, 0x13, 0x8c, 0xaa, 0x31, 0xe1, 0x0f, 0xe2,
-	0x11, 0x10, 0x60, 0xc5, 0xf8, 0xf8, 0x45, 0x02, 0xb2, 0xa7, 0xa9, 0xa2, 0x97, 0x21, 0xed, 0xf8,
-	0x44, 0x75, 0x04, 0x9b, 0x8c, 0xa5, 0x0a, 0xe6, 0x5c, 0xd0, 0x6d, 0xf6, 0x98, 0x06, 0xc8, 0x53,
-	0x99, 0x0c, 0x2e, 0x29, 0xfa, 0x7c, 0xc7, 0xb0, 0xb9, 0x08, 0x41, 0xed, 0x32, 0x5b, 0x90, 0xa6,
-	0x8c, 0x0a, 0x8a, 0x3b, 0x76, 0x0b, 0x77, 0x30, 0x73, 0x82, 0xe3, 0xea, 0xb9, 0xb6, 0x84, 0x39,
-	0x83, 0x51, 0xd1, 0x10, 0xa8, 0x06, 0x93, 0x01, 0xda, 0xc4, 0xf9, 0xd1, 0x02, 0x5d, 0x74, 0x1d,
-	0x66, 0xe2, 0x1b, 0x83, 0x3a, 0x7a, 0x4c, 0x34, 0x52, 0xb1, 0x7d, 0xe1, 0xac, 0x9d, 0x27, 0xf9,
-	0xd4, 0x9d, 0xc7, 0x9c, 0xee, 0x7e, 0x95, 0x80, 0xf9, 0x06, 0x71, 0xff, 0xf7, 0xdd, 0xb2, 0x09,
-	0xa0, 0x53, 0x55, 0x56, 0x52, 0xe3, 0x99, 0xe7, 0xc8, 0xf7, 0x69, 0x0d, 0x52, 0xe5, 0xe2, 0xbf,
-	0xe5, 0xa1, 0xbf, 0x8c, 0xc3, 0x4c, 0xdc, 0x43, 0xff, 0x97, 0x9b, 0x16, 0x5a, 0x8f, 0xca, 0xd4,
-	0x84, 0x2a, 0x53, 0xaf, 0x9c, 0x56, 0xa6, 0x46, 0xa2, 0xf9, 0x8c, 0xfa, 0xf4, 0xcb, 0x04, 0x24,
-	0x37, 0xb1, 0x8f, 0xbb, 0x1c, 0x6d, 0x8c, 0x1c, 0x64, 0xf5, 0x45, 0xf2, 0xea, 0x48, 0x30, 0x57,
-	0xcd, 0x5b, 0x87, 0x8e, 0xe5, 0x9f, 0x9f, 0x76, 0x8e, 0xfd, 0x2c, 0xcc, 0xc9, 0x0b, 0x71, 0x68,
-	0x90, 0x26, 0x77, 0x56, 0xdd, 0x6b, 0x43, 0xeb, 0x39, 0xca, 0x43, 0x4a, 0x8a, 0x45, 0x75, 0x58,
-	0xca, 0x40, 0x17, 0x1f, 0xd4, 0x74, 0x0f, 0x5a, 0x02, 0xb4, 0x17, 0x3e, 0x50, 0xd8, 0x11, 0x11,
-	0x52, 0x6e, 0x3e, 0x1a, 0x09, 0xc4, 0x5f, 0x04, 0x90, 0xab, 0xb0, 0x5d, 0xc2, 0xbc, 0xae, 0xb9,
-	0xd5, 0x4d, 0xcb, 0x9e, 0xaa, 0xec, 0x40, 0x3f, 0xb2, 0xf4, 0x79, 0xf8, 0xd8, 0xb5, 0xd9, 0x5c,
-	0x47, 0xb6, 0x9e, 0x21, 0x29, 0xfe, 0x75, 0x94, 0xcf, 0x0d, 0x70, 0xb7, 0xb3, 0x52, 0x3c, 0x01,
-	0xa7, 0x78, 0xd2, 0x4d, 0x5e, 0x1e, 0x9c, 0x87, 0xaf, 0xdd, 0x2b, 0x37, 0x64, 0x78, 0x1f, 0x7e,
-	0xf8, 0xfe, 0x4d, 0x33, 0xd3, 0x12, 0x77, 0xf7, 0xcb, 0x07, 0xe1, 0xf3, 0x95, 0xf6, 0x89, 0x3c,
-	0xa9, 0xa2, 0x68, 0xd7, 0x68, 0x10, 0xde, 0x93, 0x37, 0x3e, 0x79, 0x43, 0x88, 0x9d, 0xe4, 0xad,
-	0xa7, 0xdf, 0x10, 0x22, 0xfd, 0xa1, 0x1b, 0x42, 0x2c, 0xa7, 0xbe, 0x12, 0x15, 0xed, 0x71, 0xe3,
-	0x72, 0x83, 0xd5, 0xc2, 0x9c, 0xc4, 0xae, 0x1a, 0x74, 0x08, 0x22, 0x50, 0x52, 0xa9, 0x3a, 0x56,
-	0xfc, 0xa3, 0x05, 0x57, 0x47, 0xc2, 0x2f, 0x5c, 0xb2, 0x03, 0xc8, 0x8f, 0x0d, 0x2a, 0x37, 0x0e,
-	0xcc, 0xd2, 0x9f, 0x2f, 0x9a, 0xe7, 0xfd, 0x91, 0xca, 0xfd, 0xc9, 0xec, 0x3e, 0xa6, 0xf4, 0xfc,
-	0xde, 0x82, 0x8b, 0xf1, 0x05, 0x84, 0xa6, 0x34, 0x61, 0x26, 0x3e, 0xb5, 0x31, 0xe2, 0xc6, 0xb3,
-	0x18, 0x11, 0x5f, 0xff, 0x10, 0x08, 0xda, 0x89, 0x52, 0x5c, 0xbf, 0x9b, 0xdd, 0x7a, 0x66, 0x52,
-	0x82, 0x85, 0x9d, 0x98, 0xea, 0xda, 0x37, 0xff, 0xb0, 0x60, 0x62, 0xd3, 0xf3, 0x3a, 0xe8, 0x07,
-	0x30, 0xcf, 0x3c, 0x61, 0xcb, 0x74, 0x20, 0xae, 0x6d, 0x2e, 0xf6, 0xba, 0x7c, 0xd6, 0x9e, 0xca,
-	0xd5, 0xdf, 0x8f, 0xf2, 0xa3, 0x9a, 0xc3, 0x04, 0x9a, 0xf7, 0x23, 0xe6, 0x89, 0x8a, 0x12, 0xda,
-	0xd2, 0x77, 0xff, 0x5d, 0x98, 0x1d, 0x9e, 0x4e, 0x97, 0xd8, 0xd5, 0xb3, 0xa6, 0x9b, 0x3d, 0x73,
-	0xaa, 0x99, 0x56, 0x6c, 0x9e, 0x95, 0x29, 0xe9, 0xb5, 0x7f, 0x4a, 0xcf, 0xbd, 0x0d, 0x99, 0xb0,
-	0xbe, 0x6c, 0xab, 0xc7, 0x27, 0x2e, 0x43, 0x43, 0xbf, 0x43, 0x05, 0xa7, 0xfb, 0x42, 0xfc, 0x51,
-	0x13, 0xb7, 0x1c, 0x5a, 0x3a, 0xa6, 0x33, 0x44, 0xa7, 0xd1, 0xbd, 0xf9, 0x5b, 0x0b, 0x20, 0x7a,
-	0x24, 0x41, 0xaf, 0xc2, 0x95, 0xca, 0xc6, 0x7a, 0xd5, 0x6e, 0x6e, 0xad, 0x6e, 0x6d, 0x37, 0xed,
-	0xed, 0xf5, 0xe6, 0x66, 0x6d, 0xad, 0x7e, 0xbb, 0x5e, 0xab, 0x66, 0xc6, 0x72, 0xe9, 0xc3, 0x7b,
-	0x85, 0xd4, 0x36, 0xe3, 0x3d, 0xe2, 0xd0, 0x5d, 0x4a, 0x5c, 0xf4, 0x39, 0xb8, 0x38, 0x2c, 0x2d,
-	0x5b, 0xb5, 0x6a, 0xc6, 0xca, 0xcd, 0x1c, 0xde, 0x2b, 0x4c, 0xe9, 0x73, 0x22, 0x71, 0xd1, 0x22,
-	0x5c, 0x1a, 0x95, 0xab, 0xaf, 0xbf, 0x9e, 0x19, 0xcf, 0xcd, 0x1e, 0xde, 0x2b, 0x4c, 0x87, 0x07,
-	0x4a, 0x54, 0x04, 0x14, 0x97, 0x34, 0x78, 0x89, 0x1c, 0x1c, 0xde, 0x2b, 0x24, 0xb5, 0x17, 0x72,
-	0x13, 0xef, 0xfc, 0x7a, 0x61, 0xec, 0xe6, 0x77, 0x01, 0xea, 0x6c, 0xd7, 0xc7, 0x8e, 0x8a, 0xb6,
-	0x1c, 0x5c, 0xae, 0xaf, 0xdf, 0x6e, 0xac, 0xae, 0x6d, 0xd5, 0x37, 0xd6, 0x87, 0x97, 0x7d, 0x6c,
-	0xac, 0xba, 0xb1, 0x5d, 0x79, 0xb3, 0x66, 0x37, 0xeb, 0xaf, 0xaf, 0x67, 0x2c, 0x74, 0x05, 0x2e,
-	0x0c, 0x8d, 0x7d, 0x63, 0x7d, 0xab, 0xfe, 0x56, 0x2d, 0x33, 0x5e, 0xb9, 0xfd, 0xc1, 0xe3, 0x05,
-	0xeb, 0xe1, 0xe3, 0x05, 0xeb, 0x6f, 0x8f, 0x17, 0xac, 0x77, 0x9f, 0x2c, 0x8c, 0x3d, 0x7c, 0xb2,
-	0x30, 0xf6, 0xa7, 0x27, 0x0b, 0x63, 0xdf, 0x7a, 0xb5, 0x4d, 0xc5, 0x5e, 0xbf, 0x55, 0x72, 0xbc,
-	0xae, 0x79, 0xe6, 0x2e, 0x9f, 0x58, 0xf1, 0xd4, 0xbb, 0x72, 0x2b, 0xa9, 0x36, 0x99, 0x2f, 0xfe,
-	0x27, 0x00, 0x00, 0xff, 0xff, 0x7a, 0x6b, 0x77, 0xd8, 0xcf, 0x17, 0x00, 0x00,
+	// 1922 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0x4d, 0x6c, 0x23, 0x49,
+	0x15, 0x4e, 0xc7, 0x5e, 0x27, 0x79, 0x4e, 0x62, 0xa7, 0xe6, 0xcf, 0xe3, 0x61, 0x63, 0x8f, 0x77,
+	0x60, 0x67, 0x87, 0x8d, 0xcd, 0x04, 0x69, 0x0f, 0x01, 0x81, 0xe2, 0xd8, 0xb3, 0xe3, 0x65, 0x37,
+	0x09, 0x76, 0x12, 0x58, 0xfe, 0x5a, 0xe5, 0xee, 0x8a, 0x53, 0xc4, 0xdd, 0x6d, 0xba, 0xca, 0x43,
+	0x7c, 0xe7, 0xb0, 0x0a, 0x42, 0x5a, 0x09, 0x09, 0x21, 0xa1, 0x11, 0x23, 0xed, 0x65, 0xb9, 0xed,
+	0x61, 0xc4, 0x9d, 0xdb, 0x82, 0x84, 0x34, 0x9a, 0x13, 0x42, 0x22, 0xa0, 0x99, 0xc3, 0xae, 0xe0,
+	0x82, 0x38, 0x71, 0x44, 0xf5, 0xd3, 0x3f, 0x8e, 0xe3, 0xc9, 0x24, 0xbb, 0x42, 0x2b, 0xb8, 0xb4,
+	0xba, 0xaa, 0xde, 0xfb, 0xea, 0xbd, 0xaf, 0xde, 0x7b, 0xf5, 0x03, 0x37, 0x2c, 0x8f, 0x39, 0x1e,
+	0xab, 0x30, 0x8e, 0xf7, 0xa9, 0xdb, 0xa9, 0xdc, 0xbb, 0xdd, 0x26, 0x1c, 0xdf, 0x0e, 0xda, 0xe5,
+	0x9e, 0xef, 0x71, 0x0f, 0x5d, 0x56, 0x52, 0xe5, 0xa0, 0x57, 0x4b, 0xe5, 0x2f, 0x76, 0xbc, 0x8e,
+	0x27, 0x45, 0x2a, 0xe2, 0x4f, 0x49, 0xe7, 0xaf, 0x76, 0x3c, 0xaf, 0xd3, 0x25, 0x15, 0xd9, 0x6a,
+	0xf7, 0x77, 0x2b, 0xd8, 0x1d, 0xe8, 0xa1, 0xc5, 0xe3, 0x43, 0x76, 0xdf, 0xc7, 0x9c, 0x7a, 0xae,
+	0x1e, 0x2f, 0x1c, 0x1f, 0xe7, 0xd4, 0x21, 0x8c, 0x63, 0xa7, 0x17, 0x60, 0x2b, 0x4b, 0x4c, 0x35,
+	0xa9, 0x36, 0x4b, 0x63, 0x6b, 0x57, 0xda, 0x98, 0x91, 0xd0, 0x0f, 0xcb, 0xa3, 0x01, 0xf6, 0x02,
+	0x76, 0xa8, 0xeb, 0x55, 0xe4, 0x57, 0x77, 0x7d, 0x8e, 0x13, 0xd7, 0x26, 0xbe, 0x43, 0x5d, 0x5e,
+	0xe1, 0x83, 0x1e, 0x61, 0xea, 0xab, 0x47, 0xaf, 0xc5, 0x46, 0x71, 0xdb, 0xa2, 0xf1, 0xc1, 0xd2,
+	0xcf, 0x0d, 0x98, 0xbf, 0x4b, 0x19, 0xf7, 0x7c, 0x6a, 0xe1, 0x6e, 0xc3, 0xdd, 0xf5, 0xd0, 0x57,
+	0x20, 0xb5, 0x47, 0xb0, 0x4d, 0xfc, 0x9c, 0x51, 0x34, 0x6e, 0xa6, 0x97, 0x73, 0xe5, 0x08, 0xa0,
+	0xac, 0x74, 0xef, 0xca, 0xf1, 0xea, 0xcc, 0x87, 0x47, 0x85, 0x89, 0xf7, 0x3f, 0xfa, 0xe0, 0x96,
+	0xd1, 0xd4, 0x2a, 0xa8, 0x06, 0xa9, 0x7b, 0xb8, 0xcb, 0x08, 0xcf, 0x4d, 0x16, 0x13, 0x37, 0xd3,
+	0xcb, 0xd7, 0xcb, 0x27, 0x73, 0x5e, 0xde, 0xc1, 0x5d, 0x6a, 0x63, 0xee, 0x0d, 0xa3, 0x28, 0xdd,
+	0xd2, 0x2f, 0x26, 0x21, 0xb3, 0xe6, 0x39, 0x0e, 0x65, 0x8c, 0x7a, 0x6e, 0x13, 0x73, 0xc2, 0xd0,
+	0x1b, 0x90, 0xf4, 0x31, 0x27, 0xd2, 0xa8, 0x99, 0xea, 0x6b, 0x42, 0xe9, 0xcf, 0x47, 0x85, 0x6b,
+	0x0a, 0x9e, 0xd9, 0xfb, 0x65, 0xea, 0x55, 0x1c, 0xcc, 0xf7, 0xca, 0x6f, 0x92, 0x0e, 0xb6, 0x06,
+	0x35, 0x62, 0x3d, 0x7e, 0xb8, 0x04, 0x7a, 0xf6, 0x1a, 0xb1, 0xd4, 0x0c, 0x12, 0x03, 0x7d, 0x13,
+	0xa6, 0x1d, 0x7c, 0x60, 0x4a, 0xbc, 0xc9, 0x4f, 0x84, 0x37, 0xe5, 0xe0, 0x03, 0x61, 0x1f, 0xfa,
+	0x01, 0x64, 0x04, 0xa4, 0xb5, 0x87, 0xdd, 0x0e, 0x51, 0xc8, 0x89, 0x4f, 0x84, 0x3c, 0xe7, 0xe0,
+	0x83, 0x35, 0x89, 0x26, 0xf0, 0x57, 0x92, 0x1f, 0x3f, 0x28, 0x18, 0xa5, 0xdf, 0x19, 0x00, 0x11,
+	0x31, 0x08, 0x43, 0xd6, 0x0a, 0x5b, 0x72, 0x52, 0xa6, 0x17, 0xed, 0xe5, 0x71, 0xbc, 0x1f, 0xa3,
+	0xb5, 0x3a, 0x27, 0xcc, 0x7b, 0x74, 0x54, 0x30, 0xd4, 0xac, 0x19, 0x6b, 0x84, 0xf6, 0x74, 0xbf,
+	0x67, 0x63, 0x4e, 0x4c, 0x11, 0xc3, 0x92, 0xad, 0xf4, 0x72, 0xbe, 0xac, 0x02, 0xbc, 0x1c, 0x04,
+	0x78, 0x79, 0x2b, 0x08, 0x70, 0x05, 0xf8, 0xee, 0x5f, 0x03, 0x40, 0x50, 0xda, 0x62, 0x5c, 0xfb,
+	0xf0, 0xbe, 0x01, 0xe9, 0x1a, 0x61, 0x96, 0x4f, 0x7b, 0x22, 0x65, 0x50, 0x0e, 0xa6, 0x1c, 0xcf,
+	0xa5, 0xfb, 0x3a, 0xe0, 0x66, 0x9a, 0x41, 0x13, 0xe5, 0x61, 0x9a, 0xda, 0xc4, 0xe5, 0x94, 0x0f,
+	0xd4, 0x32, 0x35, 0xc3, 0xb6, 0xd0, 0xfa, 0x31, 0x69, 0x33, 0x1a, 0xf0, 0xdc, 0x0c, 0x9a, 0xe8,
+	0x15, 0xc8, 0x32, 0x62, 0xf5, 0x7d, 0xca, 0x07, 0xa6, 0xe5, 0xb9, 0x1c, 0x5b, 0x3c, 0x97, 0x94,
+	0x22, 0x99, 0xa0, 0x7f, 0x4d, 0x75, 0x0b, 0x10, 0x9b, 0x70, 0x4c, 0xbb, 0x2c, 0xf7, 0x82, 0x02,
+	0xd1, 0x4d, 0x6d, 0xea, 0xe1, 0x14, 0xcc, 0x84, 0x81, 0x8a, 0xd6, 0x20, 0xeb, 0xf5, 0x88, 0x2f,
+	0xfe, 0x4d, 0x6c, 0xdb, 0x3e, 0x61, 0x4c, 0x47, 0x63, 0xee, 0xf1, 0xc3, 0xa5, 0x8b, 0x9a, 0xf0,
+	0x55, 0x35, 0xd2, 0xe2, 0x3e, 0x75, 0x3b, 0xcd, 0x4c, 0xa0, 0xa1, 0xbb, 0xd1, 0xdb, 0x62, 0xc9,
+	0x5c, 0x46, 0x5c, 0xd6, 0x67, 0x66, 0xaf, 0xdf, 0xde, 0x27, 0x03, 0x4d, 0xea, 0xc5, 0x11, 0x52,
+	0x57, 0xdd, 0x41, 0x35, 0xf7, 0x87, 0x08, 0xda, 0xf2, 0x07, 0x3d, 0xee, 0x95, 0x37, 0xfb, 0xed,
+	0x6f, 0x90, 0x81, 0x58, 0x2a, 0x8d, 0xb3, 0x29, 0x61, 0xd0, 0x65, 0x48, 0xfd, 0x10, 0xd3, 0x2e,
+	0xb1, 0x25, 0x23, 0xd3, 0x4d, 0xdd, 0x42, 0x2b, 0x90, 0x62, 0x1c, 0xf3, 0x3e, 0x93, 0x34, 0xcc,
+	0x2f, 0x97, 0xc6, 0xc5, 0x46, 0xd5, 0x73, 0xed, 0x96, 0x94, 0x6c, 0x6a, 0x0d, 0xb4, 0x06, 0x29,
+	0xee, 0xed, 0x13, 0x57, 0x13, 0x54, 0xfd, 0xa2, 0x8e, 0xe6, 0x4b, 0xa3, 0xd1, 0xdc, 0x70, 0x79,
+	0x2c, 0x8e, 0x1b, 0x2e, 0x6f, 0x6a, 0x55, 0xf4, 0x3d, 0xc8, 0xda, 0xa4, 0x4b, 0x3a, 0x92, 0x39,
+	0xb6, 0x87, 0x7d, 0xc2, 0x72, 0x29, 0x09, 0x77, 0xfb, 0xcc, 0xc9, 0xd1, 0xcc, 0x84, 0x50, 0x2d,
+	0x89, 0x84, 0x36, 0x21, 0x6d, 0x47, 0xe1, 0x94, 0x9b, 0x92, 0x64, 0xbe, 0x34, 0xce, 0xc7, 0x58,
+	0xe4, 0xc5, 0x2b, 0x4f, 0x1c, 0x42, 0x44, 0x50, 0xdf, 0x6d, 0x7b, 0xae, 0x4d, 0xdd, 0x8e, 0xb9,
+	0x47, 0x68, 0x67, 0x8f, 0xe7, 0xa6, 0x8b, 0xc6, 0xcd, 0x44, 0x33, 0x13, 0xf6, 0xdf, 0x95, 0xdd,
+	0x68, 0x13, 0xe6, 0x23, 0x51, 0x99, 0x21, 0x33, 0x67, 0xcd, 0x90, 0xb9, 0x10, 0x40, 0x88, 0xa0,
+	0xb7, 0x00, 0xa2, 0x1c, 0xcc, 0x81, 0x44, 0x2b, 0x9d, 0x9e, 0xcd, 0x71, 0x67, 0x62, 0x00, 0xe8,
+	0xbb, 0x70, 0xc1, 0xa1, 0xae, 0xc9, 0x48, 0x77, 0xd7, 0xd4, 0xcc, 0x09, 0xdc, 0xf4, 0xd9, 0x57,
+	0x73, 0xc1, 0xa1, 0x6e, 0x8b, 0x74, 0x77, 0x6b, 0x21, 0x0a, 0xfa, 0x2a, 0x5c, 0x8b, 0xbc, 0xf7,
+	0x5c, 0x73, 0xcf, 0xeb, 0xda, 0xa6, 0x4f, 0x76, 0x4d, 0xcb, 0xeb, 0xbb, 0x3c, 0x37, 0x2b, 0x39,
+	0xbb, 0x12, 0x8a, 0x6c, 0xb8, 0x77, 0xbd, 0xae, 0xdd, 0x24, 0xbb, 0x6b, 0x62, 0x18, 0xbd, 0x04,
+	0x91, 0xeb, 0x26, 0xb5, 0x59, 0x6e, 0xae, 0x98, 0xb8, 0x99, 0x6c, 0xce, 0x86, 0x9d, 0x0d, 0x9b,
+	0xad, 0x4c, 0xbf, 0xf3, 0xa0, 0x30, 0xf1, 0xf1, 0x83, 0xc2, 0x44, 0xe9, 0x0e, 0xcc, 0xee, 0xe0,
+	0xae, 0xce, 0x23, 0xc2, 0xd0, 0x6b, 0x30, 0x83, 0x83, 0x46, 0xce, 0x28, 0x26, 0x9e, 0x99, 0x87,
+	0x91, 0x68, 0xe9, 0x37, 0x06, 0xa4, 0x6a, 0x3b, 0x9b, 0x98, 0xfa, 0xa8, 0x0e, 0x0b, 0x51, 0x60,
+	0x3e, 0x6f, 0x4a, 0x47, 0xb1, 0x1c, 0xe4, 0xf4, 0x3a, 0x2c, 0xdc, 0x0b, 0xaa, 0x44, 0x08, 0xa3,
+	0xf6, 0x95, 0xeb, 0x8f, 0x1f, 0x2e, 0xbd, 0xa8, 0x61, 0xc2, 0x4a, 0x72, 0x0c, 0xef, 0xde, 0xb1,
+	0xfe, 0x98, 0xcf, 0x6f, 0xc0, 0x94, 0x32, 0x95, 0xa1, 0xaf, 0xc3, 0x0b, 0x3d, 0xf1, 0x23, 0x5d,
+	0x4d, 0x2f, 0x2f, 0x8e, 0x0d, 0x70, 0x29, 0x1f, 0x0f, 0x07, 0xa5, 0x57, 0xfa, 0xe9, 0x24, 0x40,
+	0x6d, 0x67, 0x67, 0xcb, 0xa7, 0xbd, 0x2e, 0xe1, 0x9f, 0x96, 0xef, 0xdb, 0x70, 0x29, 0xf2, 0x9d,
+	0xf9, 0xd6, 0xd9, 0xfd, 0xbf, 0x10, 0xea, 0xb7, 0x7c, 0xeb, 0x44, 0x58, 0x9b, 0xf1, 0x10, 0x36,
+	0x71, 0x76, 0xd8, 0x1a, 0xe3, 0xa3, 0xcc, 0x7e, 0x1b, 0xd2, 0x11, 0x19, 0x0c, 0x35, 0x60, 0x9a,
+	0xeb, 0x7f, 0x4d, 0x70, 0x69, 0x3c, 0xc1, 0x81, 0x5a, 0x9c, 0xe4, 0x50, 0xbd, 0xf4, 0x6f, 0x03,
+	0x20, 0x96, 0x23, 0x9f, 0xcd, 0x18, 0x43, 0x0d, 0x48, 0xe9, 0x4a, 0x9c, 0x38, 0x6f, 0x25, 0xd6,
+	0x00, 0x31, 0x52, 0x7f, 0x36, 0x09, 0x17, 0xb6, 0x83, 0xec, 0xfd, 0xec, 0x73, 0xb0, 0x0d, 0x53,
+	0xc4, 0xe5, 0x3e, 0x95, 0x24, 0x88, 0x35, 0xff, 0xd2, 0xb8, 0x35, 0x3f, 0xc1, 0xa9, 0xba, 0xcb,
+	0xfd, 0x41, 0x3c, 0x02, 0x02, 0xac, 0x18, 0x1f, 0xbf, 0x4a, 0x40, 0x6e, 0x9c, 0x2a, 0x7a, 0x19,
+	0x32, 0x96, 0x4f, 0x64, 0x47, 0xb0, 0xc9, 0x18, 0xb2, 0x60, 0xce, 0x07, 0xdd, 0x7a, 0x8f, 0x69,
+	0x82, 0x38, 0x95, 0x89, 0xe0, 0x12, 0xa2, 0xe7, 0x3b, 0x86, 0xcd, 0x47, 0x08, 0x72, 0x97, 0xd9,
+	0x82, 0x0c, 0x75, 0x29, 0xa7, 0xb8, 0x6b, 0xb6, 0x71, 0x17, 0xbb, 0x56, 0x70, 0x5c, 0x3d, 0xd3,
+	0x96, 0x30, 0xaf, 0x31, 0xaa, 0x0a, 0x02, 0xd5, 0x61, 0x2a, 0x40, 0x4b, 0x9e, 0x1d, 0x2d, 0xd0,
+	0x45, 0xd7, 0x61, 0x36, 0xbe, 0x31, 0xc8, 0xa3, 0x47, 0xb2, 0x99, 0x8e, 0xed, 0x0b, 0xa7, 0xed,
+	0x3c, 0xa9, 0x67, 0xee, 0x3c, 0xfa, 0x74, 0xf7, 0xeb, 0x04, 0x2c, 0x34, 0x89, 0xfd, 0xbf, 0xbf,
+	0x2c, 0x9b, 0x00, 0x2a, 0x55, 0x45, 0x25, 0xd5, 0x2b, 0x73, 0x8e, 0x7c, 0x9f, 0x51, 0x20, 0x35,
+	0xc6, 0xff, 0x5b, 0x2b, 0xf4, 0x97, 0x49, 0x98, 0x8d, 0xaf, 0xd0, 0xff, 0xe5, 0xa6, 0x85, 0xd6,
+	0xa3, 0x32, 0x95, 0x94, 0x65, 0xea, 0x95, 0x71, 0x65, 0x6a, 0x24, 0x9a, 0x4f, 0xa9, 0x4f, 0xef,
+	0x25, 0x21, 0xb5, 0x89, 0x7d, 0xec, 0x30, 0xb4, 0x31, 0x72, 0x90, 0x55, 0x17, 0xc9, 0xab, 0x23,
+	0xc1, 0x5c, 0xd3, 0x6f, 0x1d, 0x2a, 0x96, 0x7f, 0x39, 0xee, 0x1c, 0xfb, 0x79, 0x98, 0x17, 0x17,
+	0xe2, 0xd0, 0x21, 0x45, 0xee, 0x9c, 0xbc, 0xd7, 0x86, 0xde, 0x33, 0x54, 0x80, 0xb4, 0x10, 0x8b,
+	0xea, 0xb0, 0x90, 0x01, 0x07, 0x1f, 0xd4, 0x55, 0x0f, 0x5a, 0x02, 0xb4, 0x17, 0x3e, 0x50, 0x98,
+	0x11, 0x11, 0x42, 0x6e, 0x21, 0x1a, 0x09, 0xc4, 0x5f, 0x04, 0x10, 0x56, 0x98, 0x36, 0x71, 0x3d,
+	0x47, 0xdf, 0xea, 0x66, 0x44, 0x4f, 0x4d, 0x74, 0xa0, 0x9f, 0x18, 0xea, 0x3c, 0x7c, 0xec, 0xda,
+	0xac, 0xaf, 0x23, 0x5b, 0xcf, 0x91, 0x14, 0xff, 0x3a, 0x2a, 0xe4, 0x07, 0xd8, 0xe9, 0xae, 0x94,
+	0x4e, 0xc0, 0x29, 0x9d, 0x74, 0x93, 0x17, 0x07, 0xe7, 0xe1, 0x6b, 0xb7, 0x32, 0x03, 0x1f, 0x8c,
+	0x98, 0x31, 0x75, 0x1e, 0x33, 0x46, 0x71, 0xc6, 0x98, 0x81, 0x0f, 0x86, 0xcd, 0x58, 0xb9, 0x21,
+	0xb2, 0xec, 0xf0, 0xa3, 0x0f, 0x6e, 0xe9, 0x99, 0x96, 0x98, 0xbd, 0x5f, 0x39, 0x08, 0x5f, 0xd1,
+	0x54, 0x68, 0x88, 0x03, 0x33, 0x8a, 0x36, 0xaf, 0x26, 0x61, 0x3d, 0x71, 0xf1, 0x14, 0x17, 0x95,
+	0xd8, 0x85, 0xc2, 0x78, 0xf6, 0x45, 0x25, 0xd2, 0x1f, 0xba, 0xa8, 0xc4, 0x52, 0xfb, 0x6b, 0xd1,
+	0xde, 0x31, 0xa9, 0x23, 0x4f, 0x63, 0xb5, 0x31, 0x23, 0xb1, 0x1b, 0x0f, 0x1d, 0x82, 0x08, 0x94,
+	0x64, 0xc5, 0x98, 0x28, 0xfd, 0xd1, 0x80, 0xab, 0x23, 0x59, 0x10, 0x9a, 0x6c, 0x01, 0xf2, 0x63,
+	0x83, 0x32, 0x9a, 0x06, 0xda, 0xf4, 0xf3, 0x25, 0xd5, 0x82, 0x3f, 0xb2, 0x81, 0x7c, 0x3a, 0x9b,
+	0xa0, 0xae, 0x80, 0xbf, 0x37, 0xe0, 0x62, 0xdc, 0x80, 0xd0, 0x95, 0x16, 0xcc, 0xc6, 0xa7, 0xd6,
+	0x4e, 0xdc, 0x78, 0x1e, 0x27, 0xe2, 0xf6, 0x0f, 0x81, 0xa0, 0x9d, 0xa8, 0xd2, 0xa8, 0xe7, 0xbb,
+	0xdb, 0xcf, 0x4d, 0x4a, 0x60, 0xd8, 0x89, 0x15, 0x47, 0xad, 0xcd, 0x3f, 0x0c, 0x48, 0x6e, 0x7a,
+	0x5e, 0x17, 0xfd, 0x08, 0x16, 0x5c, 0x8f, 0x9b, 0x22, 0x2b, 0x89, 0x6d, 0xea, 0xf7, 0x05, 0x55,
+	0xc5, 0xeb, 0xcf, 0xe4, 0xea, 0xef, 0x47, 0x85, 0x51, 0xcd, 0x61, 0x02, 0xf5, 0x33, 0x96, 0xeb,
+	0xf1, 0xaa, 0x14, 0xda, 0x52, 0x4f, 0x10, 0xbb, 0x30, 0x37, 0x3c, 0x9d, 0xaa, 0xf4, 0xab, 0xa7,
+	0x4d, 0x37, 0x77, 0xea, 0x54, 0xb3, 0xed, 0xd8, 0x3c, 0x2b, 0xd3, 0x62, 0xd5, 0xfe, 0x29, 0x56,
+	0xee, 0x6d, 0xc8, 0x86, 0x65, 0x6e, 0x5b, 0xbe, 0x81, 0x31, 0x11, 0x1a, 0xea, 0x39, 0x2c, 0xb8,
+	0x64, 0x14, 0xe3, 0x6f, 0xab, 0xb8, 0x6d, 0xd1, 0xf2, 0x31, 0x9d, 0x21, 0x3a, 0xb5, 0xee, 0xad,
+	0xdf, 0x1a, 0x00, 0xd1, 0x5b, 0x0d, 0x7a, 0x15, 0xae, 0x54, 0x37, 0xd6, 0x6b, 0x66, 0x6b, 0x6b,
+	0x75, 0x6b, 0xbb, 0x65, 0x6e, 0xaf, 0xb7, 0x36, 0xeb, 0x6b, 0x8d, 0x3b, 0x8d, 0x7a, 0x2d, 0x3b,
+	0x91, 0xcf, 0x1c, 0xde, 0x2f, 0xa6, 0xb7, 0x5d, 0xd6, 0x23, 0x16, 0xdd, 0xa5, 0xc4, 0x46, 0x5f,
+	0x80, 0x8b, 0xc3, 0xd2, 0xa2, 0x55, 0xaf, 0x65, 0x8d, 0xfc, 0xec, 0xe1, 0xfd, 0xe2, 0xb4, 0x3a,
+	0xae, 0x12, 0x1b, 0xdd, 0x84, 0x4b, 0xa3, 0x72, 0x8d, 0xf5, 0xd7, 0xb3, 0x93, 0xf9, 0xb9, 0xc3,
+	0xfb, 0xc5, 0x99, 0xf0, 0x5c, 0x8b, 0x4a, 0x80, 0xe2, 0x92, 0x1a, 0x2f, 0x91, 0x87, 0xc3, 0xfb,
+	0xc5, 0x94, 0x5a, 0x85, 0x7c, 0xf2, 0x9d, 0xf7, 0x16, 0x27, 0x6e, 0x7d, 0x1f, 0xa0, 0xe1, 0xee,
+	0xfa, 0xd8, 0x92, 0xd1, 0x96, 0x87, 0xcb, 0x8d, 0xf5, 0x3b, 0xcd, 0xd5, 0xb5, 0xad, 0xc6, 0xc6,
+	0xfa, 0xb0, 0xd9, 0xc7, 0xc6, 0x6a, 0x1b, 0xdb, 0xd5, 0x37, 0xeb, 0x66, 0xab, 0xf1, 0xfa, 0x7a,
+	0xd6, 0x40, 0x57, 0xe0, 0xc2, 0xd0, 0xd8, 0xb7, 0xd6, 0xb7, 0x1a, 0x6f, 0xd5, 0xb3, 0x93, 0xd5,
+	0x3b, 0x1f, 0x3e, 0x59, 0x34, 0x1e, 0x3d, 0x59, 0x34, 0xfe, 0xf6, 0x64, 0xd1, 0x78, 0xf7, 0xe9,
+	0xe2, 0xc4, 0xa3, 0xa7, 0x8b, 0x13, 0x7f, 0x7a, 0xba, 0x38, 0xf1, 0x9d, 0x57, 0x3b, 0x94, 0xef,
+	0xf5, 0xdb, 0x65, 0xcb, 0x73, 0xf4, 0x6b, 0x7b, 0xe5, 0xc4, 0x8a, 0x27, 0x9f, 0xb7, 0xdb, 0x29,
+	0xb9, 0xd7, 0x7d, 0xf9, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1d, 0x41, 0x58, 0x63, 0x56, 0x18,
+	0x00, 0x00,
 }
 
 func (this *Pool) Description() (desc *github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet) {
@@ -1404,797 +1408,799 @@ func (this *Pool) Description() (desc *github_com_cosmos_gogoproto_protoc_gen_go
 func StakingDescription() (desc *github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet) {
 	d := &github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet{}
 	var gzipped = []byte{
-		// 12640 bytes of a gzipped FileDescriptorSet
-		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x6b, 0x90, 0x63, 0xc7,
-		0x75, 0x18, 0x3c, 0x17, 0x6f, 0x1c, 0x60, 0x80, 0x3b, 0x3d, 0xb3, 0xbb, 0x58, 0x2c, 0xb9, 0x33,
-		0x04, 0x45, 0x72, 0xb9, 0x24, 0x67, 0xb9, 0x43, 0xee, 0x92, 0x3b, 0x2b, 0x8a, 0x1f, 0x5e, 0xbb,
-		0x8b, 0xe5, 0x0c, 0x30, 0xbc, 0xc0, 0x2c, 0xb9, 0xb4, 0xad, 0xeb, 0x3b, 0x40, 0xcf, 0xcc, 0xe5,
-		0x02, 0xf7, 0x42, 0xb8, 0x17, 0xcb, 0x19, 0x7e, 0x55, 0x2e, 0xda, 0x92, 0x1d, 0x9a, 0xb2, 0x1c,
-		0x39, 0x72, 0xd9, 0xb4, 0xa5, 0x95, 0x25, 0x39, 0xb6, 0xe4, 0x57, 0x22, 0xcb, 0x8a, 0x1f, 0x49,
-		0xc5, 0xb1, 0xf3, 0xb4, 0x55, 0x4e, 0x22, 0xbb, 0x2a, 0x89, 0x9d, 0x2a, 0x33, 0xb1, 0xe4, 0x32,
-		0xa9, 0x87, 0xe3, 0x17, 0x9d, 0x38, 0xa5, 0x4a, 0x29, 0xd5, 0xaf, 0xfb, 0xc0, 0x63, 0x80, 0x59,
-		0x51, 0x0e, 0x63, 0xe7, 0xcf, 0x0c, 0xba, 0xfb, 0x9c, 0xd3, 0xdd, 0xa7, 0x4f, 0x9f, 0x3e, 0xe7,
-		0xf4, 0xe3, 0xc2, 0x87, 0x30, 0x2c, 0xed, 0x98, 0xe6, 0x4e, 0x1b, 0x9f, 0xe9, 0xf6, 0x4c, 0xdb,
-		0xdc, 0xea, 0x6f, 0x9f, 0x69, 0x61, 0xab, 0xd9, 0xd3, 0xbb, 0xb6, 0xd9, 0x5b, 0xa6, 0x79, 0x28,
-		0xcd, 0x20, 0x96, 0x05, 0x44, 0xee, 0x73, 0x12, 0xcc, 0x5d, 0xd2, 0xdb, 0xb8, 0xe4, 0x40, 0xd6,
-		0xb1, 0x8d, 0x1e, 0x87, 0xd0, 0xb6, 0xde, 0xc6, 0x19, 0x69, 0x29, 0x78, 0x2a, 0xb1, 0xf2, 0x8e,
-		0xe5, 0x01, 0xac, 0x65, 0x3f, 0xc6, 0x06, 0xc9, 0x56, 0x28, 0xc6, 0xe9, 0xff, 0x3f, 0xf6, 0xd2,
-		0x57, 0x3f, 0xf7, 0x75, 0x49, 0xfe, 0x4e, 0xf2, 0x37, 0xdb, 0x41, 0x37, 0x58, 0x1a, 0x3d, 0xba,
-		0x4c, 0xf0, 0x3c, 0xed, 0xb9, 0x79, 0x96, 0xe4, 0xa8, 0x04, 0x49, 0x75, 0xb3, 0x55, 0x0b, 0xdb,
-		0x2a, 0xde, 0xb3, 0xb1, 0x61, 0xe9, 0xa6, 0x91, 0x7d, 0x68, 0x04, 0xd6, 0x50, 0x6b, 0xcb, 0x02,
-		0x3c, 0xf7, 0x6a, 0x18, 0xe6, 0x47, 0x34, 0x0d, 0x21, 0x08, 0x19, 0x5a, 0x87, 0x74, 0x47, 0x3a,
-		0x15, 0x57, 0xe8, 0x6f, 0x94, 0x81, 0x68, 0x57, 0x6b, 0xde, 0xd0, 0x76, 0x70, 0x26, 0x40, 0xb3,
-		0x45, 0x12, 0x9d, 0x04, 0x68, 0xe1, 0x2e, 0x36, 0x5a, 0xd8, 0x68, 0xee, 0x67, 0x82, 0x4b, 0xc1,
-		0x53, 0x71, 0xc5, 0x93, 0x83, 0x1e, 0x80, 0xb9, 0x6e, 0x7f, 0xab, 0xad, 0x37, 0x55, 0x0f, 0x18,
-		0x2c, 0x05, 0x4f, 0x85, 0x15, 0x99, 0x15, 0x94, 0x5c, 0xe0, 0xfb, 0x20, 0xfd, 0x02, 0xd6, 0x6e,
-		0x78, 0x41, 0x13, 0x14, 0x34, 0x45, 0xb2, 0x3d, 0x80, 0x45, 0x48, 0x76, 0xb0, 0x65, 0x69, 0x3b,
-		0x58, 0xb5, 0xf7, 0xbb, 0x38, 0x13, 0xa2, 0xac, 0x5f, 0x1a, 0x62, 0xfd, 0x20, 0xdb, 0x13, 0x1c,
+		// 12660 bytes of a gzipped FileDescriptorSet
+		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x7b, 0x90, 0x5b, 0xd7,
+		0x79, 0x18, 0xbe, 0x17, 0x6f, 0x7c, 0xc0, 0x02, 0x77, 0xcf, 0x2e, 0x49, 0x10, 0x94, 0xb8, 0x2b,
+		0xc8, 0x92, 0x28, 0x4a, 0x5a, 0x8a, 0x2b, 0x91, 0x12, 0x97, 0x96, 0xf5, 0xc3, 0x8b, 0x24, 0xa8,
+		0x5d, 0x60, 0x75, 0x81, 0xa5, 0x44, 0x25, 0xf1, 0xcd, 0x5d, 0xe0, 0xec, 0xee, 0x15, 0x81, 0x7b,
+		0x61, 0xdc, 0x0b, 0x6a, 0x57, 0xbf, 0x99, 0x8c, 0x12, 0x3b, 0xa9, 0x22, 0xc7, 0xa9, 0x53, 0x67,
+		0x12, 0x25, 0x0e, 0x1d, 0x3f, 0x9a, 0xd8, 0x79, 0xb5, 0x8e, 0xe3, 0xe6, 0xd1, 0x4e, 0xd3, 0xa4,
+		0xcf, 0xc4, 0x93, 0x76, 0x9c, 0xcc, 0x34, 0x4d, 0x3a, 0x13, 0xb5, 0xb1, 0x33, 0x91, 0xfc, 0x48,
+		0xf3, 0x52, 0xda, 0x74, 0x3c, 0x1d, 0x77, 0xce, 0xeb, 0x3e, 0xf0, 0x58, 0x60, 0x69, 0x39, 0x55,
+		0x93, 0xfe, 0x43, 0xee, 0x3d, 0xe7, 0xfb, 0xbe, 0xf3, 0x9d, 0xef, 0x7c, 0xe7, 0x3b, 0xdf, 0xf7,
+		0x9d, 0x07, 0xe0, 0x43, 0x18, 0x96, 0x76, 0x4c, 0x73, 0xa7, 0x8d, 0xcf, 0x74, 0x7b, 0xa6, 0x6d,
+		0x6e, 0xf5, 0xb7, 0xcf, 0xb4, 0xb0, 0xd5, 0xec, 0xe9, 0x5d, 0xdb, 0xec, 0x2d, 0xd3, 0x32, 0x94,
+		0x66, 0x10, 0xcb, 0x02, 0x22, 0xf7, 0x39, 0x09, 0xe6, 0x2e, 0xe9, 0x6d, 0x5c, 0x72, 0x20, 0xeb,
+		0xd8, 0x46, 0x8f, 0x43, 0x68, 0x5b, 0x6f, 0xe3, 0x8c, 0xb4, 0x14, 0x3c, 0x95, 0x58, 0x79, 0xc7,
+		0xf2, 0x00, 0xd6, 0xb2, 0x1f, 0x63, 0x83, 0x14, 0x2b, 0x14, 0xe3, 0xf4, 0xff, 0x1f, 0x7b, 0xe9,
+		0xab, 0x9f, 0xfb, 0xba, 0x24, 0x7f, 0x27, 0xf9, 0x37, 0xdb, 0x41, 0x37, 0xd8, 0x37, 0x7a, 0x74,
+		0x99, 0xe0, 0x79, 0xf8, 0xb9, 0x79, 0x96, 0x94, 0xa8, 0x04, 0x49, 0x75, 0x8b, 0x55, 0x0b, 0xdb,
+		0x2a, 0xde, 0xb3, 0xb1, 0x61, 0xe9, 0xa6, 0x91, 0x7d, 0x68, 0x04, 0xd6, 0x10, 0xb7, 0x65, 0x01,
+		0x9e, 0x7b, 0x35, 0x0c, 0xf3, 0x23, 0x58, 0x43, 0x08, 0x42, 0x86, 0xd6, 0x21, 0xdd, 0x91, 0x4e,
+		0xc5, 0x15, 0xfa, 0x37, 0xca, 0x40, 0xb4, 0xab, 0x35, 0x6f, 0x68, 0x3b, 0x38, 0x13, 0xa0, 0xc5,
+		0xe2, 0x13, 0x9d, 0x04, 0x68, 0xe1, 0x2e, 0x36, 0x5a, 0xd8, 0x68, 0xee, 0x67, 0x82, 0x4b, 0xc1,
+		0x53, 0x71, 0xc5, 0x53, 0x82, 0x1e, 0x80, 0xb9, 0x6e, 0x7f, 0xab, 0xad, 0x37, 0x55, 0x0f, 0x18,
+		0x2c, 0x05, 0x4f, 0x85, 0x15, 0x99, 0x55, 0x94, 0x5c, 0xe0, 0xfb, 0x20, 0xfd, 0x02, 0xd6, 0x6e,
+		0x78, 0x41, 0x13, 0x14, 0x34, 0x45, 0x8a, 0x3d, 0x80, 0x45, 0x48, 0x76, 0xb0, 0x65, 0x69, 0x3b,
+		0x58, 0xb5, 0xf7, 0xbb, 0x38, 0x13, 0xa2, 0xa2, 0x5f, 0x1a, 0x12, 0xfd, 0xa0, 0xd8, 0x13, 0x1c,
 		0xab, 0xb1, 0xdf, 0xc5, 0x28, 0x0f, 0x71, 0x6c, 0xf4, 0x3b, 0x8c, 0x42, 0x78, 0xcc, 0xe0, 0x95,
 		0x8d, 0x7e, 0x67, 0x90, 0x4a, 0x8c, 0xa0, 0x71, 0x12, 0x51, 0x0b, 0xf7, 0x6e, 0xea, 0x4d, 0x9c,
-		0x89, 0x50, 0x02, 0xf7, 0x0d, 0x11, 0xa8, 0xb3, 0xf2, 0x41, 0x1a, 0x02, 0x0f, 0x15, 0x21, 0xee,
-		0x0c, 0x61, 0x26, 0x4a, 0x89, 0xdc, 0x33, 0x42, 0x84, 0x70, 0xbb, 0x35, 0x48, 0xc2, 0xc5, 0x43,
+		0x89, 0x50, 0x02, 0xf7, 0x0d, 0x11, 0xa8, 0xb3, 0xfa, 0x41, 0x1a, 0x02, 0x0f, 0x15, 0x21, 0xee,
+		0x0c, 0x61, 0x26, 0x4a, 0x89, 0xdc, 0x33, 0x42, 0x85, 0x70, 0xbb, 0x35, 0x48, 0xc2, 0xc5, 0x43,
 		0xe7, 0x21, 0x6a, 0x76, 0x6d, 0xdd, 0x34, 0xac, 0x4c, 0x6c, 0x49, 0x3a, 0x95, 0x58, 0xb9, 0x63,
-		0xa4, 0x14, 0xd6, 0x18, 0x8c, 0x22, 0x80, 0x51, 0x05, 0x64, 0xcb, 0xec, 0xf7, 0x9a, 0x58, 0x6d,
+		0xa4, 0x16, 0xd6, 0x18, 0x8c, 0x22, 0x80, 0x51, 0x05, 0x64, 0xcb, 0xec, 0xf7, 0x9a, 0x58, 0x6d,
 		0x9a, 0x2d, 0xac, 0xea, 0xc6, 0xb6, 0x99, 0x89, 0x53, 0x02, 0x8b, 0xc3, 0x1d, 0xa1, 0x80, 0x45,
-		0xb3, 0x85, 0x2b, 0xc6, 0xb6, 0xa9, 0xa4, 0x2c, 0x5f, 0x1a, 0x1d, 0x85, 0x88, 0xb5, 0x6f, 0xd8,
-		0xda, 0x5e, 0x26, 0x49, 0x25, 0x84, 0xa7, 0xd0, 0x0a, 0x44, 0x71, 0x4b, 0x27, 0xd5, 0x65, 0x52,
-		0x4b, 0xd2, 0xa9, 0xd4, 0x4a, 0x66, 0x98, 0xc7, 0xac, 0x5c, 0x11, 0x80, 0xb9, 0x5f, 0x89, 0x40,
-		0x7a, 0x1a, 0xb1, 0xbc, 0x08, 0xe1, 0x6d, 0xc2, 0x99, 0x4c, 0xe0, 0x30, 0x7c, 0x63, 0x38, 0x7e,
-		0xc6, 0x47, 0x6e, 0x93, 0xf1, 0x79, 0x48, 0x18, 0xd8, 0xb2, 0x71, 0x8b, 0x49, 0x51, 0x70, 0x4a,
-		0x39, 0x04, 0x86, 0x34, 0x2c, 0x86, 0xa1, 0xdb, 0x12, 0xc3, 0x67, 0x21, 0xed, 0x34, 0x49, 0xed,
-		0x69, 0xc6, 0x8e, 0x90, 0xe7, 0x33, 0x93, 0x5a, 0xb2, 0xec, 0xe8, 0x03, 0x85, 0xa0, 0x29, 0x29,
-		0xec, 0x4b, 0xa3, 0x12, 0x80, 0x69, 0x60, 0x73, 0x5b, 0x6d, 0xe1, 0x66, 0x3b, 0x13, 0x1b, 0xc3,
-		0xa5, 0x1a, 0x01, 0x19, 0xe2, 0x92, 0xc9, 0x72, 0x9b, 0x6d, 0x74, 0xc1, 0x15, 0xcf, 0xe8, 0x18,
-		0xe9, 0x5a, 0x67, 0x13, 0x73, 0x48, 0x42, 0x37, 0x21, 0xd5, 0xc3, 0x64, 0xae, 0xe0, 0x16, 0xef,
-		0x59, 0x9c, 0x36, 0x62, 0x79, 0x62, 0xcf, 0x14, 0x8e, 0xc6, 0x3a, 0x36, 0xdb, 0xf3, 0x26, 0xd1,
-		0xdd, 0xe0, 0x64, 0xa8, 0x54, 0xac, 0x80, 0x6a, 0xae, 0xa4, 0xc8, 0xac, 0x6a, 0x1d, 0x9c, 0x7d,
-		0x11, 0x52, 0x7e, 0xf6, 0xa0, 0x05, 0x08, 0x5b, 0xb6, 0xd6, 0xb3, 0xa9, 0x14, 0x86, 0x15, 0x96,
-		0x40, 0x32, 0x04, 0xb1, 0xd1, 0xa2, 0x9a, 0x31, 0xac, 0x90, 0x9f, 0xe8, 0xff, 0x73, 0x3b, 0x1c,
-		0xa4, 0x1d, 0xbe, 0x77, 0x78, 0x44, 0x7d, 0x94, 0x07, 0xfb, 0x9d, 0x7d, 0x0c, 0x66, 0x7d, 0x1d,
-		0x98, 0xb6, 0xea, 0xdc, 0x6f, 0x85, 0xe0, 0xc8, 0x48, 0xda, 0xe8, 0x59, 0x58, 0xe8, 0x1b, 0xba,
-		0x61, 0xe3, 0x5e, 0xb7, 0x87, 0x89, 0xc8, 0xb2, 0xba, 0x32, 0xaf, 0x47, 0xc7, 0x08, 0xdd, 0xa6,
-		0x17, 0x9a, 0x51, 0x51, 0xe6, 0xfb, 0xc3, 0x99, 0xe8, 0x3a, 0x24, 0x88, 0x7c, 0x68, 0x3d, 0x8d,
-		0x12, 0x64, 0xb3, 0x71, 0x65, 0xba, 0x2e, 0x2f, 0x97, 0x5c, 0xcc, 0x42, 0xf0, 0x65, 0x29, 0xa0,
-		0x78, 0x69, 0xa1, 0xc7, 0x20, 0xb6, 0x8d, 0x35, 0xbb, 0xdf, 0xc3, 0x56, 0x66, 0x85, 0xb2, 0xf2,
-		0xc4, 0xf0, 0x24, 0x65, 0x00, 0x75, 0x6c, 0x2b, 0x0e, 0x30, 0xea, 0x40, 0xf2, 0x26, 0xee, 0xe9,
-		0xdb, 0x7a, 0x93, 0x35, 0x2a, 0x48, 0x95, 0xcf, 0xe3, 0x53, 0x36, 0xea, 0x9a, 0x07, 0xb5, 0x6e,
-		0x6b, 0x36, 0x5e, 0x85, 0xcd, 0xea, 0xb5, 0xb2, 0x52, 0xb9, 0x54, 0x29, 0x97, 0x58, 0x33, 0x7d,
-		0xe4, 0xb3, 0x3f, 0x28, 0x41, 0xc2, 0xd3, 0x13, 0xa2, 0x0e, 0x8d, 0x7e, 0x67, 0x0b, 0xf7, 0xf8,
-		0x78, 0xf1, 0x14, 0x3a, 0x01, 0xf1, 0xed, 0x7e, 0xbb, 0xcd, 0x84, 0x8e, 0xad, 0xa5, 0x31, 0x92,
-		0x41, 0x04, 0x8e, 0xe8, 0x38, 0xae, 0x46, 0xa8, 0x8e, 0x23, 0xbf, 0x51, 0x16, 0x62, 0x42, 0x28,
-		0x33, 0xe1, 0x25, 0xe9, 0x54, 0x4c, 0x71, 0xd2, 0xac, 0xac, 0x8b, 0x35, 0x1b, 0xb7, 0x32, 0x11,
-		0x51, 0xc6, 0xd2, 0x57, 0x43, 0xb1, 0x90, 0x1c, 0xce, 0x3d, 0x0a, 0x73, 0x43, 0x5d, 0x41, 0x69,
-		0x48, 0x94, 0xca, 0xc5, 0xb5, 0xbc, 0x92, 0x6f, 0x54, 0x6a, 0x55, 0x79, 0x06, 0xa5, 0xc0, 0xd3,
-		0x3b, 0x59, 0x3a, 0x1d, 0x8f, 0xbd, 0x11, 0x95, 0x5f, 0x7a, 0xe9, 0xa5, 0x97, 0x02, 0xb9, 0x5f,
-		0x8f, 0xc0, 0xc2, 0x28, 0x25, 0x38, 0x52, 0x1f, 0xbb, 0x9d, 0x0e, 0xfa, 0x3a, 0x9d, 0x87, 0x70,
-		0x5b, 0xdb, 0xc2, 0xed, 0x4c, 0x88, 0x0e, 0xc2, 0x03, 0x53, 0xa9, 0xd9, 0xe5, 0x35, 0x82, 0xa2,
-		0x30, 0x4c, 0xf4, 0x2e, 0xce, 0x9a, 0x30, 0xa5, 0x70, 0x7a, 0x3a, 0x0a, 0x44, 0x39, 0x72, 0x36,
-		0x9e, 0x80, 0x38, 0xf9, 0xcf, 0xf8, 0x1e, 0x61, 0x7c, 0x27, 0x19, 0x94, 0xef, 0x59, 0x88, 0x51,
-		0xbd, 0xd7, 0xc2, 0xce, 0x98, 0x88, 0x34, 0xd1, 0x14, 0x2d, 0xbc, 0xad, 0xf5, 0xdb, 0xb6, 0x7a,
-		0x53, 0x6b, 0xf7, 0x31, 0xd5, 0x60, 0x71, 0x25, 0xc9, 0x33, 0xaf, 0x91, 0x3c, 0xb4, 0x08, 0x09,
-		0xa6, 0x26, 0x75, 0xa3, 0x85, 0xf7, 0xe8, 0x12, 0x1a, 0x56, 0x98, 0xe6, 0xac, 0x90, 0x1c, 0x52,
-		0xfd, 0xf3, 0x96, 0x69, 0x08, 0x5d, 0x43, 0xab, 0x20, 0x19, 0xb4, 0xfa, 0xc7, 0x06, 0x57, 0xef,
-		0x3b, 0x47, 0x77, 0x6f, 0x48, 0x39, 0xde, 0x07, 0x69, 0x0a, 0xf1, 0x08, 0x9f, 0xca, 0x5a, 0x3b,
-		0x33, 0x47, 0xc5, 0x20, 0xc5, 0xb2, 0x6b, 0x3c, 0x37, 0xf7, 0x8b, 0x01, 0x08, 0xd1, 0x95, 0x22,
-		0x0d, 0x89, 0xc6, 0xf5, 0x8d, 0xb2, 0x5a, 0xaa, 0x6d, 0x16, 0xd6, 0xca, 0xb2, 0x44, 0x86, 0x9e,
-		0x66, 0x5c, 0x5a, 0xab, 0xe5, 0x1b, 0x72, 0xc0, 0x49, 0x57, 0xaa, 0x8d, 0xf3, 0x8f, 0xca, 0x41,
-		0x07, 0x61, 0x93, 0x65, 0x84, 0xbc, 0x00, 0x8f, 0xac, 0xc8, 0x61, 0x24, 0x43, 0x92, 0x11, 0xa8,
-		0x3c, 0x5b, 0x2e, 0x9d, 0x7f, 0x54, 0x8e, 0xf8, 0x73, 0x1e, 0x59, 0x91, 0xa3, 0x68, 0x16, 0xe2,
-		0x34, 0xa7, 0x50, 0xab, 0xad, 0xc9, 0x31, 0x87, 0x66, 0xbd, 0xa1, 0x54, 0xaa, 0x97, 0xe5, 0xb8,
-		0x43, 0xf3, 0xb2, 0x52, 0xdb, 0xdc, 0x90, 0xc1, 0xa1, 0xb0, 0x5e, 0xae, 0xd7, 0xf3, 0x97, 0xcb,
-		0x72, 0xc2, 0x81, 0x28, 0x5c, 0x6f, 0x94, 0xeb, 0x72, 0xd2, 0xd7, 0xac, 0x47, 0x56, 0xe4, 0x59,
-		0xa7, 0x8a, 0x72, 0x75, 0x73, 0x5d, 0x4e, 0xa1, 0x39, 0x98, 0x65, 0x55, 0x88, 0x46, 0xa4, 0x07,
-		0xb2, 0xce, 0x3f, 0x2a, 0xcb, 0x6e, 0x43, 0x18, 0x95, 0x39, 0x5f, 0xc6, 0xf9, 0x47, 0x65, 0x94,
-		0x2b, 0x42, 0x98, 0x8a, 0x21, 0x42, 0x90, 0x5a, 0xcb, 0x17, 0xca, 0x6b, 0x6a, 0x6d, 0x83, 0x4c,
-		0x9a, 0xfc, 0x9a, 0x2c, 0xb9, 0x79, 0x4a, 0x79, 0xa3, 0x9c, 0x6f, 0x94, 0x4b, 0x72, 0xd0, 0x9b,
-		0xf7, 0xf4, 0x66, 0x45, 0x29, 0x97, 0xe4, 0x40, 0xae, 0x09, 0x0b, 0xa3, 0x56, 0xc8, 0x91, 0x53,
-		0xc8, 0x23, 0x0b, 0x81, 0x31, 0xb2, 0x40, 0x69, 0x0d, 0xca, 0x42, 0xee, 0x8b, 0x01, 0x98, 0x1f,
-		0x61, 0x25, 0x8c, 0xac, 0xe4, 0x49, 0x08, 0x33, 0x59, 0x66, 0x9a, 0xfa, 0xfe, 0x91, 0xe6, 0x06,
-		0x95, 0xec, 0x21, 0xdb, 0x89, 0xe2, 0x79, 0xed, 0xcd, 0xe0, 0x18, 0x7b, 0x93, 0x90, 0x18, 0x12,
-		0xd8, 0x6f, 0x1b, 0x5a, 0xcd, 0x99, 0xc1, 0x73, 0x7e, 0x1a, 0x83, 0x87, 0xe6, 0x1d, 0x6e, 0x55,
-		0x0f, 0x8f, 0x58, 0xd5, 0x2f, 0xc2, 0xdc, 0x10, 0xa1, 0xa9, 0x57, 0xd7, 0xf7, 0x4a, 0x90, 0x19,
-		0xc7, 0x9c, 0x09, 0x2a, 0x31, 0xe0, 0x53, 0x89, 0x17, 0x07, 0x39, 0x78, 0xd7, 0xf8, 0x41, 0x18,
-		0x1a, 0xeb, 0x4f, 0x4a, 0x70, 0x74, 0xb4, 0x5f, 0x31, 0xb2, 0x0d, 0xef, 0x82, 0x48, 0x07, 0xdb,
-		0xbb, 0xa6, 0xb0, 0x93, 0xef, 0x1d, 0x61, 0x7d, 0x91, 0xe2, 0xc1, 0xc1, 0xe6, 0x58, 0x5e, 0xf3,
-		0x2d, 0x38, 0xce, 0x39, 0x60, 0xad, 0x19, 0x6a, 0xe9, 0xf7, 0x06, 0xe0, 0xc8, 0x48, 0xe2, 0x23,
-		0x1b, 0x7a, 0x27, 0x80, 0x6e, 0x74, 0xfb, 0x36, 0xb3, 0x85, 0x99, 0x26, 0x8e, 0xd3, 0x1c, 0xaa,
-		0xbc, 0x88, 0x96, 0xed, 0xdb, 0x4e, 0x39, 0x5b, 0x25, 0x81, 0x65, 0x51, 0x80, 0xc7, 0xdd, 0x86,
-		0x86, 0x68, 0x43, 0x4f, 0x8e, 0xe9, 0xe9, 0x90, 0x60, 0x3e, 0x0c, 0x72, 0xb3, 0xad, 0x63, 0xc3,
-		0x56, 0x2d, 0xbb, 0x87, 0xb5, 0x8e, 0x6e, 0xec, 0xb0, 0xd5, 0x76, 0x35, 0xbc, 0xad, 0xb5, 0x2d,
-		0xac, 0xa4, 0x59, 0x71, 0x5d, 0x94, 0x12, 0x0c, 0x2a, 0x40, 0x3d, 0x0f, 0x46, 0xc4, 0x87, 0xc1,
-		0x8a, 0x1d, 0x8c, 0xdc, 0xcf, 0xc5, 0x21, 0xe1, 0xf1, 0xc2, 0xd0, 0x5d, 0x90, 0x7c, 0x5e, 0xbb,
-		0xa9, 0xa9, 0xc2, 0xb3, 0x66, 0x9c, 0x48, 0x90, 0xbc, 0x0d, 0xee, 0x5d, 0x3f, 0x0c, 0x0b, 0x14,
-		0xc4, 0xec, 0xdb, 0xb8, 0xa7, 0x36, 0xdb, 0x9a, 0x65, 0x51, 0xa6, 0xc5, 0x28, 0x28, 0x22, 0x65,
-		0x35, 0x52, 0x54, 0x14, 0x25, 0xe8, 0x1c, 0xcc, 0x53, 0x8c, 0x4e, 0xbf, 0x6d, 0xeb, 0xdd, 0x36,
-		0xa6, 0x31, 0x03, 0x8b, 0x2e, 0x39, 0x4e, 0xcb, 0xe6, 0x08, 0xc4, 0x3a, 0x07, 0x20, 0x2d, 0xb2,
-		0x50, 0x09, 0xee, 0xa4, 0x68, 0x3b, 0xd8, 0xc0, 0x3d, 0xcd, 0xc6, 0x2a, 0x7e, 0x4f, 0x5f, 0x6b,
-		0x5b, 0xaa, 0x66, 0xb4, 0xd4, 0x5d, 0xcd, 0xda, 0xcd, 0x2c, 0x10, 0x02, 0x85, 0x40, 0x46, 0x52,
-		0x8e, 0x13, 0xc0, 0xcb, 0x1c, 0xae, 0x4c, 0xc1, 0xf2, 0x46, 0xeb, 0x8a, 0x66, 0xed, 0xa2, 0x55,
-		0x38, 0x4a, 0xa9, 0x58, 0x76, 0x4f, 0x37, 0x76, 0xd4, 0xe6, 0x2e, 0x6e, 0xde, 0x50, 0xfb, 0xf6,
-		0xf6, 0xe3, 0x99, 0x13, 0xde, 0xfa, 0x69, 0x0b, 0xeb, 0x14, 0xa6, 0x48, 0x40, 0x36, 0xed, 0xed,
-		0xc7, 0x51, 0x1d, 0x92, 0x64, 0x30, 0x3a, 0xfa, 0x8b, 0x58, 0xdd, 0x36, 0x7b, 0x74, 0x0d, 0x4d,
-		0x8d, 0x50, 0x4d, 0x1e, 0x0e, 0x2e, 0xd7, 0x38, 0xc2, 0xba, 0xd9, 0xc2, 0xab, 0xe1, 0xfa, 0x46,
-		0xb9, 0x5c, 0x52, 0x12, 0x82, 0xca, 0x25, 0xb3, 0x47, 0x04, 0x6a, 0xc7, 0x74, 0x18, 0x9c, 0x60,
-		0x02, 0xb5, 0x63, 0x0a, 0xf6, 0x9e, 0x83, 0xf9, 0x66, 0x93, 0xf5, 0x59, 0x6f, 0xaa, 0xdc, 0x23,
-		0xb7, 0x32, 0xb2, 0x8f, 0x59, 0xcd, 0xe6, 0x65, 0x06, 0xc0, 0x65, 0xdc, 0x42, 0x17, 0xe0, 0x88,
-		0xcb, 0x2c, 0x2f, 0xe2, 0xdc, 0x50, 0x2f, 0x07, 0x51, 0xcf, 0xc1, 0x7c, 0x77, 0x7f, 0x18, 0x11,
-		0xf9, 0x6a, 0xec, 0xee, 0x0f, 0xa2, 0xdd, 0x43, 0xa3, 0x2c, 0x3d, 0xdc, 0xa4, 0xa6, 0xde, 0x31,
-		0x2f, 0xb4, 0xa7, 0x00, 0x2d, 0x83, 0xdc, 0x6c, 0xaa, 0xd8, 0xd0, 0xb6, 0xda, 0x58, 0xd5, 0x7a,
-		0xd8, 0xd0, 0xac, 0xcc, 0x22, 0x05, 0x0e, 0xd9, 0xbd, 0x3e, 0x56, 0x52, 0xcd, 0x66, 0x99, 0x16,
-		0xe6, 0x69, 0x19, 0x3a, 0x0d, 0x73, 0xe6, 0xd6, 0xf3, 0x4d, 0x26, 0x58, 0x6a, 0xb7, 0x87, 0xb7,
-		0xf5, 0xbd, 0xcc, 0x3b, 0x28, 0x97, 0xd2, 0xa4, 0x80, 0x8a, 0xd5, 0x06, 0xcd, 0x46, 0xf7, 0x83,
-		0xdc, 0xb4, 0x76, 0xb5, 0x5e, 0x97, 0x6a, 0x56, 0xab, 0xab, 0x35, 0x71, 0xe6, 0x1e, 0x06, 0xca,
-		0xf2, 0xab, 0x22, 0x9b, 0x08, 0xb6, 0xf5, 0x82, 0xbe, 0x6d, 0x0b, 0x8a, 0xf7, 0x31, 0xc1, 0xa6,
-		0x79, 0x9c, 0xda, 0x29, 0x90, 0xbb, 0xbb, 0x5d, 0x7f, 0xc5, 0xa7, 0x28, 0x58, 0xaa, 0xbb, 0xdb,
-		0xf5, 0xd6, 0x7b, 0x37, 0xcc, 0x12, 0x48, 0xb7, 0xd2, 0xfb, 0x99, 0xfd, 0xd5, 0xdd, 0xf5, 0xd4,
-		0xf8, 0x28, 0x1c, 0x25, 0x40, 0x1d, 0x6c, 0x6b, 0x2d, 0xcd, 0xd6, 0x3c, 0xd0, 0x0f, 0x52, 0xe8,
-		0x85, 0xee, 0x6e, 0x77, 0x9d, 0x17, 0xfa, 0xda, 0xd9, 0xeb, 0x6f, 0xed, 0x3b, 0xf2, 0xf1, 0x10,
-		0x6b, 0x27, 0xc9, 0x13, 0x12, 0x72, 0xdb, 0xee, 0xc7, 0x37, 0xcd, 0xd9, 0xca, 0xad, 0x42, 0xd2,
-		0x2b, 0xf7, 0x28, 0x0e, 0x4c, 0xf2, 0x65, 0x89, 0x18, 0x41, 0xc5, 0x5a, 0x89, 0x98, 0x2f, 0xcf,
-		0x95, 0xe5, 0x00, 0x31, 0xa3, 0xd6, 0x2a, 0x8d, 0xb2, 0xaa, 0x6c, 0x56, 0x1b, 0x95, 0xf5, 0xb2,
-		0x1c, 0xf4, 0x18, 0xf6, 0x57, 0x43, 0xb1, 0xd3, 0xf2, 0x03, 0x57, 0x43, 0xb1, 0x7b, 0xe5, 0xfb,
-		0x28, 0x7b, 0x86, 0x84, 0x32, 0xf7, 0x66, 0x10, 0x52, 0x7e, 0xb7, 0x1c, 0xbd, 0x13, 0x8e, 0x89,
-		0xb8, 0x9b, 0x85, 0x6d, 0xf5, 0x05, 0xbd, 0x47, 0x27, 0x6b, 0x47, 0x63, 0x0b, 0xa7, 0x23, 0x94,
-		0x0b, 0x1c, 0xaa, 0x8e, 0xed, 0x67, 0xf4, 0x1e, 0x99, 0x8a, 0x1d, 0xcd, 0x46, 0x6b, 0xb0, 0x68,
-		0x98, 0xaa, 0x65, 0x6b, 0x46, 0x4b, 0xeb, 0xb5, 0xbc, 0x81, 0x4c, 0xad, 0xd9, 0xc4, 0x96, 0x65,
-		0xb2, 0x45, 0xd2, 0xa1, 0x72, 0x87, 0x61, 0xd6, 0x39, 0xb0, 0xbb, 0x7a, 0xe4, 0x39, 0xe8, 0xc0,
-		0x9c, 0x08, 0x8e, 0x9b, 0x13, 0x27, 0x20, 0xde, 0xd1, 0xba, 0x2a, 0x36, 0xec, 0xde, 0x3e, 0xb5,
-		0xdd, 0x63, 0x4a, 0xac, 0xa3, 0x75, 0xcb, 0x24, 0x8d, 0xae, 0xc1, 0xbd, 0x2e, 0xa8, 0xda, 0xc6,
-		0x3b, 0x5a, 0x73, 0x5f, 0xa5, 0x86, 0x3a, 0x8d, 0x11, 0xa9, 0x4d, 0xd3, 0xd8, 0x6e, 0xeb, 0x4d,
-		0xdb, 0xa2, 0xba, 0x83, 0xe9, 0xbf, 0x9c, 0x8b, 0xb1, 0x46, 0x11, 0xae, 0x5a, 0xa6, 0x41, 0xed,
-		0xf3, 0xa2, 0x80, 0xf6, 0x89, 0x4d, 0xf2, 0x6d, 0x21, 0x36, 0xfe, 0xa1, 0x0f, 0xc9, 0xe1, 0xab,
-		0xa1, 0x58, 0x58, 0x8e, 0x5c, 0x0d, 0xc5, 0x22, 0x72, 0xf4, 0x6a, 0x28, 0x16, 0x93, 0xe3, 0x57,
-		0x43, 0xb1, 0xb8, 0x0c, 0xb9, 0x5b, 0xb3, 0x90, 0xf4, 0xba, 0x1b, 0xc4, 0x7b, 0x6b, 0xd2, 0x05,
-		0x57, 0xa2, 0x2a, 0xf9, 0xee, 0x03, 0x9d, 0x93, 0xe5, 0x22, 0x59, 0x89, 0x57, 0x23, 0xcc, 0xb6,
-		0x57, 0x18, 0x26, 0xb1, 0x82, 0xc8, 0x24, 0xc3, 0xcc, 0x96, 0x8a, 0x29, 0x3c, 0x85, 0x2e, 0x43,
-		0xe4, 0x79, 0x8b, 0xd2, 0x8e, 0x50, 0xda, 0xef, 0x38, 0x98, 0xf6, 0xd5, 0x3a, 0x25, 0x1e, 0xbf,
-		0x5a, 0x57, 0xab, 0x35, 0x65, 0x3d, 0xbf, 0xa6, 0x70, 0x74, 0x74, 0x1c, 0x42, 0x6d, 0xed, 0xc5,
-		0x7d, 0xff, 0x9a, 0x4d, 0xb3, 0xd0, 0x32, 0xa4, 0xfb, 0x06, 0xf3, 0xd5, 0xc9, 0x18, 0x13, 0xa8,
-		0xb4, 0x17, 0x2a, 0xe5, 0x96, 0xae, 0x11, 0xf8, 0x29, 0xe5, 0xea, 0x38, 0x84, 0x5e, 0xc0, 0xda,
-		0x0d, 0xff, 0xca, 0x4a, 0xb3, 0xd0, 0x29, 0x48, 0xb6, 0xf0, 0x56, 0x7f, 0x47, 0xed, 0xe1, 0x96,
-		0xd6, 0xb4, 0xfd, 0xeb, 0x49, 0x82, 0x16, 0x29, 0xb4, 0x04, 0x3d, 0x05, 0x71, 0x32, 0x46, 0x06,
-		0x1d, 0xe3, 0x39, 0xca, 0x82, 0x87, 0x0e, 0x66, 0x01, 0x1f, 0x62, 0x81, 0xa4, 0xb8, 0xf8, 0xe8,
-		0x0a, 0x44, 0x6d, 0xad, 0xb7, 0x83, 0x6d, 0x2b, 0x33, 0xbf, 0x14, 0x3c, 0x95, 0x1a, 0x11, 0x23,
-		0x1b, 0x41, 0xaa, 0x41, 0x51, 0xa8, 0xa7, 0x2c, 0xd0, 0xd1, 0x33, 0x20, 0xf3, 0x50, 0xac, 0xca,
-		0xdd, 0x5c, 0x2b, 0xb3, 0x40, 0x05, 0xf0, 0xc1, 0x83, 0x49, 0xf2, 0x48, 0x6e, 0x89, 0x21, 0x29,
-		0x69, 0xec, 0x4b, 0xfb, 0xe7, 0xc5, 0x91, 0xc3, 0xcc, 0x8b, 0x4d, 0x48, 0xf3, 0xdf, 0xaa, 0xd5,
-		0xef, 0x76, 0xcd, 0x9e, 0x9d, 0x39, 0x4a, 0xf1, 0x27, 0x34, 0x48, 0x10, 0x63, 0x38, 0x4a, 0x6a,
-		0xdb, 0x97, 0xfe, 0xe6, 0x4d, 0xb7, 0xec, 0x73, 0x90, 0xf2, 0x33, 0xc3, 0x1b, 0x08, 0x0f, 0x4e,
-		0x19, 0x08, 0x27, 0x6e, 0x89, 0x70, 0xd4, 0xc8, 0xd2, 0xc4, 0x12, 0xd9, 0x1f, 0x0a, 0x40, 0xca,
-		0xdf, 0x31, 0x74, 0x19, 0x90, 0x18, 0x31, 0xdd, 0xb0, 0x7b, 0x66, 0xab, 0xdf, 0xc4, 0x2d, 0x3e,
-		0x61, 0xc7, 0xd7, 0x33, 0xc7, 0x71, 0x2a, 0x0e, 0x8a, 0x97, 0x90, 0x67, 0x16, 0x04, 0xa6, 0x24,
-		0x54, 0x72, 0xe7, 0xc7, 0x19, 0x98, 0x17, 0x04, 0x08, 0xb1, 0x17, 0xb4, 0x9e, 0x41, 0x4c, 0x64,
-		0x66, 0xb4, 0x23, 0x4f, 0xd1, 0x33, 0xac, 0x04, 0xe5, 0x41, 0x88, 0x8b, 0xda, 0xc3, 0x1d, 0xf3,
-		0x26, 0x6e, 0xf1, 0x70, 0xd1, 0xf8, 0x6a, 0x53, 0x1c, 0x41, 0x61, 0xf0, 0xb9, 0x33, 0x10, 0xa6,
-		0xea, 0x07, 0x01, 0x70, 0x05, 0x24, 0xcf, 0xa0, 0x18, 0x84, 0x8a, 0x35, 0x85, 0x2c, 0x8f, 0x32,
-		0x24, 0x59, 0xae, 0xba, 0x51, 0x29, 0x17, 0xcb, 0x72, 0x20, 0x77, 0x0e, 0x22, 0x4c, 0xa7, 0x90,
-		0xa5, 0xd3, 0xd1, 0x2a, 0xf2, 0x0c, 0x4f, 0x72, 0x1a, 0x92, 0x28, 0xdd, 0x5c, 0x2f, 0x94, 0x15,
-		0x39, 0x90, 0xdb, 0x84, 0xf4, 0xc0, 0x3c, 0x44, 0x47, 0x60, 0x4e, 0x29, 0x37, 0xca, 0xd5, 0x46,
-		0xa5, 0x56, 0x55, 0x37, 0xab, 0x4f, 0x55, 0x6b, 0xcf, 0x54, 0xe5, 0x19, 0x7f, 0xb6, 0x58, 0x87,
-		0x25, 0xb4, 0x00, 0xb2, 0x9b, 0x5d, 0xaf, 0x6d, 0x2a, 0xb4, 0x35, 0xdf, 0x17, 0x00, 0x79, 0x70,
-		0x52, 0xa2, 0x63, 0x30, 0xdf, 0xc8, 0x2b, 0x97, 0xcb, 0x0d, 0x95, 0x05, 0x3c, 0x1c, 0xd2, 0x0b,
-		0x20, 0x7b, 0x0b, 0x2e, 0x55, 0x68, 0x3c, 0x67, 0x11, 0x4e, 0x78, 0x73, 0xcb, 0xcf, 0x36, 0xca,
-		0xd5, 0x3a, 0xad, 0x3c, 0x5f, 0xbd, 0x4c, 0x8c, 0x82, 0x01, 0x7a, 0x22, 0xc4, 0x12, 0x24, 0x4d,
-		0xf5, 0xd3, 0x2b, 0xaf, 0x95, 0xe4, 0xd0, 0x60, 0x76, 0xad, 0x5a, 0xae, 0x5d, 0x92, 0xc3, 0x83,
-		0xb5, 0xd3, 0xb0, 0x4b, 0x04, 0x65, 0xe1, 0xe8, 0x60, 0xae, 0x5a, 0xae, 0x36, 0x94, 0xeb, 0x72,
-		0x74, 0xb0, 0xe2, 0x7a, 0x59, 0xb9, 0x56, 0x29, 0x96, 0xe5, 0x18, 0x3a, 0x0a, 0xc8, 0xdf, 0xa2,
-		0xc6, 0x95, 0x5a, 0x49, 0x8e, 0x8f, 0x5a, 0xb1, 0x90, 0x3c, 0x9f, 0xfb, 0x59, 0x09, 0x92, 0xde,
-		0x10, 0x88, 0x4f, 0xa9, 0x48, 0x6f, 0xb7, 0xc5, 0x36, 0xf7, 0xdb, 0x01, 0x48, 0x78, 0x62, 0x21,
-		0xc4, 0x89, 0xd5, 0xda, 0x6d, 0xf3, 0x05, 0x55, 0x6b, 0xeb, 0x9a, 0xc5, 0xd7, 0x43, 0xa0, 0x59,
-		0x79, 0x92, 0x33, 0xed, 0xfa, 0x33, 0xbd, 0xe9, 0x12, 0xb9, 0x6d, 0xd3, 0x25, 0xfa, 0x36, 0x34,
-		0x5d, 0xc2, 0x72, 0x24, 0xf7, 0xbb, 0x01, 0x90, 0x07, 0xa3, 0x23, 0x03, 0x7c, 0x93, 0xc6, 0xf1,
-		0xcd, 0xdb, 0xbf, 0xc0, 0x61, 0xfa, 0x37, 0xb8, 0xaa, 0x07, 0xc7, 0xae, 0xea, 0x23, 0x16, 0xab,
-		0xd0, 0xdb, 0x79, 0xb1, 0xf2, 0x8a, 0xeb, 0x7f, 0x90, 0x20, 0xe5, 0x0f, 0xe6, 0xf8, 0x38, 0x96,
-		0x3b, 0x0c, 0xc7, 0xfc, 0x23, 0x72, 0xd7, 0xb8, 0x11, 0xf9, 0x6b, 0xe9, 0xd7, 0x8f, 0x04, 0x61,
-		0xd6, 0x17, 0xfb, 0x99, 0xb6, 0x75, 0xef, 0x81, 0x39, 0xbd, 0x85, 0x3b, 0x5d, 0xd3, 0xc6, 0x46,
-		0x73, 0x5f, 0x6d, 0xe3, 0x9b, 0xb8, 0x4d, 0xd9, 0x90, 0x1a, 0xb1, 0xbb, 0xea, 0xab, 0x61, 0xb9,
-		0xe2, 0xe2, 0xad, 0x11, 0xb4, 0xd5, 0xf9, 0x4a, 0xa9, 0xbc, 0xbe, 0x51, 0x6b, 0x94, 0xab, 0xc5,
-		0xeb, 0x42, 0x93, 0x2b, 0xb2, 0x3e, 0x00, 0xe6, 0x63, 0xf8, 0xdd, 0x6f, 0x0f, 0xa7, 0x73, 0x03,
-		0xe4, 0xc1, 0xde, 0x10, 0x85, 0x3e, 0xa2, 0x3f, 0xf2, 0x0c, 0x9a, 0x87, 0x74, 0xb5, 0xa6, 0xd6,
-		0x2b, 0xa5, 0xb2, 0x5a, 0xbe, 0x74, 0xa9, 0x5c, 0x6c, 0xd4, 0xd9, 0x46, 0x83, 0x03, 0xdd, 0x90,
-		0x03, 0xde, 0xb1, 0xf9, 0xd1, 0x20, 0xcc, 0x8f, 0x68, 0x09, 0xca, 0xf3, 0x10, 0x21, 0x8b, 0x5a,
-		0x3e, 0x34, 0x4d, 0xeb, 0x97, 0x89, 0x77, 0xbf, 0xa1, 0xf5, 0x6c, 0x1e, 0x51, 0xbc, 0x1f, 0x08,
-		0x7b, 0x0d, 0x9b, 0x98, 0xf7, 0x3d, 0xbe, 0x81, 0xc3, 0x4c, 0x90, 0xb4, 0x9b, 0xcf, 0xf6, 0x70,
-		0x1e, 0x04, 0xd4, 0x35, 0x2d, 0xdd, 0xd6, 0x6f, 0x62, 0x62, 0x43, 0x71, 0x60, 0x32, 0x71, 0x43,
-		0x8a, 0x2c, 0x4a, 0x2a, 0x86, 0xed, 0x40, 0x1b, 0x78, 0x47, 0x1b, 0x80, 0x26, 0xee, 0x47, 0x50,
-		0x91, 0x45, 0x89, 0x03, 0x7d, 0x17, 0x24, 0x5b, 0x66, 0x7f, 0xab, 0x8d, 0x39, 0x1c, 0x51, 0xc9,
-		0x92, 0x92, 0x60, 0x79, 0x0e, 0x08, 0x0f, 0x9b, 0xb9, 0xdb, 0x4c, 0x49, 0x25, 0xc1, 0xf2, 0x18,
-		0xc8, 0x7d, 0x90, 0xd6, 0x76, 0x76, 0x7a, 0x84, 0xb8, 0x20, 0xc4, 0x02, 0x81, 0x29, 0x27, 0x9b,
-		0x02, 0x66, 0xaf, 0x42, 0x4c, 0xf0, 0x81, 0xf8, 0xbf, 0x84, 0x13, 0x6a, 0x97, 0x45, 0xb7, 0x03,
-		0xa7, 0xe2, 0x4a, 0xcc, 0x10, 0x85, 0x77, 0x41, 0x52, 0xb7, 0xdc, 0x23, 0x44, 0x99, 0xc0, 0x52,
-		0xe0, 0x54, 0x4c, 0x49, 0xe8, 0x96, 0x7b, 0x4c, 0xe8, 0xf7, 0x66, 0x01, 0x5c, 0x61, 0x43, 0x3f,
-		0x20, 0x41, 0x8a, 0x2d, 0x30, 0xdd, 0x1e, 0xb6, 0xb0, 0xd1, 0x14, 0x6e, 0xe1, 0xfd, 0x07, 0x88,
-		0x28, 0x53, 0x73, 0x1b, 0x1c, 0xa1, 0xf0, 0xe4, 0xcb, 0x92, 0xf4, 0xaa, 0x14, 0x7a, 0x55, 0x92,
-		0x3e, 0x21, 0xcd, 0xa2, 0x58, 0xf9, 0xd9, 0x8d, 0xb5, 0x4a, 0xb1, 0xd2, 0xc8, 0xbc, 0x2f, 0x4a,
-		0xd3, 0x95, 0x75, 0x9e, 0x7e, 0x3d, 0xea, 0x2f, 0x7f, 0x23, 0xfa, 0x19, 0x29, 0x18, 0x7b, 0x23,
-		0xaa, 0xcc, 0x6e, 0x7b, 0xe9, 0xa1, 0xb6, 0xf7, 0x04, 0x45, 0x60, 0x9c, 0x23, 0xe9, 0xb6, 0xa6,
-		0xcc, 0xcf, 0x4d, 0x14, 0xee, 0xa7, 0x0d, 0x89, 0xd0, 0x86, 0x24, 0x50, 0xa4, 0xb8, 0x56, 0xab,
-		0x97, 0x4b, 0xb4, 0x19, 0x71, 0x14, 0xaa, 0x6d, 0x94, 0xab, 0x99, 0xd7, 0x45, 0x95, 0xee, 0x61,
-		0x8b, 0x57, 0x25, 0x38, 0x26, 0x76, 0x59, 0xf9, 0x5a, 0x8b, 0x8d, 0xa6, 0xd9, 0x12, 0xd6, 0x6d,
-		0x6a, 0xe5, 0xec, 0x41, 0x95, 0x2b, 0x1c, 0x95, 0xb2, 0xa4, 0xcc, 0x11, 0x0b, 0x0f, 0x0d, 0xb1,
-		0x24, 0x5f, 0x2d, 0xf1, 0xb6, 0x24, 0x50, 0x64, 0x23, 0x5f, 0x7c, 0xaa, 0x5c, 0x72, 0x5b, 0x73,
-		0xa4, 0x37, 0x8a, 0x0a, 0xfa, 0x0e, 0x48, 0xf7, 0xed, 0xed, 0xc7, 0x89, 0x6c, 0xe8, 0x2d, 0xb6,
-		0xed, 0x1d, 0x1a, 0xb7, 0x5f, 0xea, 0xb6, 0x68, 0xd3, 0xde, 0x7e, 0xfc, 0x9a, 0x83, 0xc1, 0x99,
-		0xc2, 0x9a, 0x12, 0x47, 0xa1, 0x6a, 0xad, 0x5a, 0x16, 0xcd, 0xa0, 0x5b, 0xc4, 0xd7, 0xdd, 0x66,
-		0xa4, 0xfa, 0x3e, 0x54, 0xf4, 0x1d, 0x20, 0x8b, 0xf0, 0x90, 0xc3, 0x92, 0xf0, 0xb8, 0x2d, 0x5f,
-		0xb7, 0x01, 0x3c, 0xc8, 0xe4, 0x30, 0xe3, 0x5e, 0x4f, 0x0b, 0x16, 0x50, 0x7a, 0xad, 0x5c, 0xbd,
-		0xdc, 0xb8, 0xa2, 0x6e, 0x28, 0x65, 0xba, 0x73, 0x97, 0x79, 0x9f, 0xa8, 0x3e, 0xdd, 0xf1, 0x23,
-		0xa2, 0xef, 0x92, 0x20, 0xc1, 0x4c, 0x20, 0x16, 0x93, 0x62, 0x41, 0x85, 0x7b, 0x0f, 0xaa, 0x9b,
-		0x5a, 0x40, 0x14, 0xba, 0x70, 0x81, 0x56, 0x1b, 0x14, 0x02, 0x71, 0x0c, 0xa1, 0xb5, 0xf2, 0xe5,
-		0x7c, 0xf1, 0xba, 0x5a, 0x28, 0xd7, 0x1b, 0x44, 0x93, 0xd5, 0x14, 0x26, 0xa3, 0x80, 0xc2, 0xf9,
-		0xb5, 0xb5, 0xda, 0x33, 0x2e, 0x23, 0xe0, 0x79, 0x87, 0x0c, 0xfa, 0x19, 0x09, 0x16, 0xb0, 0xb1,
-		0x6d, 0xf6, 0x9a, 0x74, 0xb7, 0x99, 0xcc, 0x68, 0xcb, 0xde, 0x6f, 0xb3, 0x19, 0x3d, 0xd2, 0x29,
-		0xf7, 0x4a, 0x26, 0xc5, 0xab, 0x52, 0xb4, 0x3a, 0xc1, 0x2a, 0x54, 0x5e, 0x96, 0x02, 0xaf, 0x92,
-		0x86, 0x05, 0x68, 0xdb, 0x42, 0xaf, 0x4a, 0x61, 0xda, 0xc2, 0xe8, 0xab, 0x52, 0xec, 0x55, 0x29,
-		0xfe, 0x09, 0x69, 0x0e, 0x25, 0xeb, 0x8d, 0xeb, 0x6b, 0x65, 0x95, 0xb5, 0x96, 0xb6, 0x30, 0x85,
-		0xe2, 0x34, 0x6f, 0xe5, 0xe1, 0x95, 0x47, 0x33, 0x5f, 0xa2, 0xad, 0xfc, 0x52, 0x54, 0x41, 0x78,
-		0x88, 0x7c, 0xee, 0x5b, 0x61, 0xd6, 0x37, 0x39, 0x89, 0x09, 0x4f, 0x4d, 0x7f, 0xc2, 0xef, 0x7a,
-		0xb9, 0x5a, 0xf4, 0xba, 0x1c, 0x49, 0x70, 0x26, 0xa3, 0x2c, 0x91, 0x94, 0x98, 0xaa, 0x72, 0x80,
-		0x28, 0x7d, 0xce, 0x2e, 0x67, 0xe7, 0x33, 0x98, 0x7b, 0x0c, 0x62, 0x62, 0xb2, 0x11, 0x47, 0x82,
-		0xfa, 0x03, 0x03, 0x6e, 0x4c, 0x0c, 0xe8, 0x4c, 0x93, 0x25, 0xe2, 0xb4, 0xb1, 0x19, 0x28, 0x07,
-		0x72, 0xd7, 0xe0, 0xc8, 0xc8, 0x89, 0x82, 0xee, 0x86, 0x45, 0xb1, 0xdb, 0xca, 0x5c, 0x14, 0xb5,
-		0x5c, 0x2d, 0xd6, 0x4a, 0xc4, 0xa9, 0x73, 0x69, 0x02, 0xf0, 0x19, 0xc3, 0x5a, 0x29, 0x66, 0x93,
-		0x1c, 0xc8, 0x55, 0x20, 0xe5, 0x17, 0x77, 0x74, 0x02, 0x8e, 0x6d, 0x36, 0x2e, 0x3d, 0xae, 0x5e,
-		0xcb, 0xaf, 0x55, 0x4a, 0xf9, 0x01, 0xf7, 0x0d, 0x80, 0xcb, 0xbc, 0x1c, 0x20, 0x0d, 0x25, 0x73,
-		0x41, 0x0e, 0xe6, 0x42, 0x31, 0x49, 0x96, 0x72, 0x75, 0x48, 0x0f, 0x08, 0x2e, 0xba, 0x03, 0x32,
-		0xdc, 0x9f, 0x1a, 0xd5, 0x2a, 0xca, 0x21, 0x9f, 0x28, 0x33, 0xcf, 0xb2, 0x54, 0x5e, 0xab, 0xac,
-		0x57, 0x1a, 0xb4, 0x7d, 0x57, 0x00, 0x5c, 0x89, 0x24, 0x2b, 0xec, 0xd5, 0x7a, 0xad, 0xaa, 0x5e,
-		0x22, 0x6e, 0x69, 0xc3, 0x43, 0x2a, 0x0e, 0x4c, 0x02, 0x65, 0x89, 0x78, 0x4f, 0xc3, 0x62, 0x2a,
-		0x07, 0x72, 0xcf, 0x00, 0x1a, 0x96, 0x26, 0xb4, 0x04, 0x77, 0x94, 0xab, 0x97, 0x6a, 0x4a, 0xb1,
-		0xac, 0x56, 0xf3, 0xeb, 0xa4, 0x7d, 0x4c, 0x76, 0x5c, 0xd2, 0xb3, 0xe0, 0x8a, 0x8e, 0xf0, 0x99,
-		0x5d, 0xe9, 0x92, 0x03, 0xa7, 0x3f, 0x2d, 0x91, 0x95, 0xfb, 0xfd, 0xd5, 0xec, 0x27, 0x25, 0x74,
-		0x67, 0xec, 0x8d, 0x28, 0x8a, 0x2e, 0x77, 0xb7, 0x96, 0x9b, 0xdd, 0x6e, 0x36, 0x4d, 0x7e, 0x14,
-		0xbb, 0xdd, 0x4b, 0xc2, 0x1e, 0x59, 0x8c, 0x7d, 0x29, 0x8a, 0x62, 0x24, 0xf7, 0x79, 0xed, 0xa6,
-		0x96, 0x95, 0xc9, 0xaf, 0xab, 0xda, 0x4d, 0xcd, 0x01, 0x38, 0x11, 0xfb, 0x72, 0x14, 0x45, 0x48,
-		0xf6, 0x8e, 0x99, 0x4d, 0x91, 0xff, 0x97, 0x4d, 0xa7, 0xf0, 0xee, 0xd8, 0x57, 0xa2, 0x08, 0x48,
-		0x66, 0x77, 0xdf, 0xde, 0x35, 0x8d, 0x2c, 0x22, 0xbf, 0x37, 0xe8, 0x6f, 0x0f, 0xd0, 0xf7, 0x54,
-		0x39, 0x10, 0x99, 0x4f, 0x67, 0x39, 0x10, 0xfd, 0x2d, 0x80, 0x4e, 0x47, 0x62, 0xef, 0xaf, 0xca,
-		0x1f, 0xac, 0x9e, 0x8e, 0xc4, 0x3e, 0x58, 0x95, 0x7f, 0xa0, 0x7a, 0x35, 0x12, 0x7b, 0x3d, 0x2a,
-		0xbf, 0x11, 0xcd, 0xfd, 0x49, 0x10, 0x90, 0x3b, 0xfb, 0x9c, 0x28, 0xd5, 0xb3, 0x10, 0x73, 0xc2,
-		0x5e, 0xec, 0x50, 0xef, 0x3b, 0x0f, 0x98, 0xb4, 0x02, 0xcd, 0x93, 0x35, 0x10, 0x06, 0x73, 0xa8,
-		0xa1, 0x3c, 0xa4, 0x3b, 0xba, 0xa1, 0x77, 0xfa, 0x1d, 0x55, 0xc4, 0x82, 0x26, 0xc6, 0x38, 0x38,
-		0x02, 0x4f, 0x53, 0x12, 0xda, 0x9e, 0x8f, 0x44, 0x78, 0x22, 0x09, 0x86, 0xc0, 0xd3, 0xd9, 0xbf,
-		0x92, 0x20, 0x33, 0xae, 0xb1, 0xb7, 0x15, 0xa6, 0xaa, 0xc2, 0x82, 0x79, 0x13, 0xf7, 0x7a, 0x7a,
-		0x8b, 0xee, 0x3c, 0x39, 0xc6, 0x6b, 0x68, 0xb2, 0xf1, 0x3a, 0xef, 0x41, 0x74, 0x06, 0xb5, 0x40,
-		0x6c, 0x8c, 0x3d, 0xb2, 0xbc, 0x0a, 0x4a, 0xe1, 0xc9, 0x94, 0x66, 0x29, 0x8a, 0xa0, 0x71, 0x95,
-		0x4c, 0x52, 0xe2, 0x2f, 0x06, 0xe4, 0xa0, 0x6b, 0x21, 0xe7, 0x3e, 0x1a, 0x84, 0x94, 0xff, 0x20,
-		0x2b, 0x2a, 0x41, 0xac, 0x6d, 0xf2, 0x43, 0x62, 0x6c, 0xb4, 0x4f, 0x4d, 0x38, 0xfb, 0xba, 0xbc,
-		0xc6, 0xe1, 0x15, 0x07, 0x33, 0xfb, 0xef, 0x24, 0x88, 0x89, 0x6c, 0x74, 0x14, 0x42, 0x5d, 0xcd,
-		0xde, 0xa5, 0xe4, 0xc2, 0x85, 0x80, 0x2c, 0x29, 0x34, 0x4d, 0xf2, 0xad, 0xae, 0xc6, 0x0e, 0xc8,
-		0xf1, 0x7c, 0x92, 0x26, 0x56, 0x6a, 0x1b, 0x6b, 0x2d, 0xba, 0x67, 0x6a, 0x76, 0x3a, 0xd8, 0xb0,
-		0x2d, 0x61, 0xa5, 0xf2, 0xfc, 0x22, 0xcf, 0x46, 0x0f, 0xc0, 0x9c, 0xdd, 0xd3, 0xf4, 0xb6, 0x0f,
-		0x36, 0x44, 0x61, 0x65, 0x51, 0xe0, 0x00, 0xaf, 0xc2, 0x71, 0x41, 0xb7, 0x85, 0x6d, 0xad, 0xb9,
-		0x8b, 0x5b, 0x2e, 0x52, 0x84, 0x9e, 0x8d, 0x38, 0xc6, 0x01, 0x4a, 0xbc, 0x5c, 0xe0, 0x9e, 0xee,
-		0xfb, 0xce, 0xa6, 0xef, 0x20, 0xcc, 0xcf, 0xa6, 0x9f, 0x1d, 0x73, 0x36, 0x7d, 0xf0, 0x1c, 0xb1,
-		0xe7, 0x60, 0xfa, 0xe9, 0x11, 0x28, 0x7e, 0x8e, 0xba, 0xe6, 0xe6, 0xe7, 0x03, 0x30, 0x27, 0x36,
-		0x97, 0x5b, 0xce, 0x18, 0xad, 0x03, 0x68, 0x86, 0x61, 0xda, 0xde, 0x51, 0x1a, 0xf6, 0x07, 0x86,
-		0xf0, 0x96, 0xf3, 0x0e, 0x92, 0xe2, 0x21, 0x90, 0xfd, 0x8a, 0x04, 0xe0, 0x16, 0x8d, 0x1d, 0xae,
-		0x45, 0x48, 0xf0, 0x5e, 0xd1, 0xf3, 0xfd, 0x2c, 0x06, 0x0b, 0x2c, 0xeb, 0x92, 0xde, 0xa6, 0xa7,
-		0x46, 0xb6, 0xf0, 0x8e, 0x6e, 0xf0, 0xe3, 0x6e, 0x2c, 0x21, 0x4e, 0x8d, 0x84, 0xdc, 0xe3, 0xa0,
-		0x0a, 0xc4, 0x2c, 0xdc, 0xd1, 0x0c, 0x5b, 0x6f, 0xf2, 0xc9, 0x7a, 0xfe, 0x50, 0x8d, 0x5f, 0xae,
-		0x73, 0x6c, 0xc5, 0xa1, 0x93, 0x3b, 0x05, 0x31, 0x91, 0xeb, 0x2c, 0x4d, 0x33, 0x28, 0x0a, 0xc1,
-		0x7a, 0x99, 0x2c, 0xce, 0x74, 0x85, 0xa8, 0xe4, 0xeb, 0x72, 0xe0, 0xf4, 0x27, 0x03, 0x10, 0x15,
-		0xda, 0x63, 0x1e, 0xd2, 0xe5, 0x52, 0x65, 0x60, 0x95, 0x9b, 0x87, 0x94, 0xc8, 0xe4, 0x5a, 0xfe,
-		0x7d, 0x51, 0x6f, 0xe6, 0x86, 0x52, 0x6b, 0xd4, 0x56, 0xe4, 0x3f, 0x1a, 0xce, 0x7c, 0x44, 0x7e,
-		0x3d, 0x8a, 0xe6, 0x20, 0x29, 0x32, 0x57, 0x1e, 0x5e, 0x79, 0x44, 0x7e, 0x63, 0x30, 0xeb, 0x51,
-		0xf9, 0x4b, 0x34, 0xfc, 0x27, 0xb2, 0xce, 0xaa, 0x0d, 0xb2, 0x54, 0xd5, 0xaa, 0x6b, 0xd7, 0x65,
-		0xc9, 0x5b, 0xb0, 0xe2, 0x29, 0x08, 0xa0, 0x3b, 0xe1, 0x98, 0x28, 0xb8, 0x70, 0xe1, 0xc2, 0x85,
-		0xc7, 0x3c, 0x85, 0xb7, 0x3e, 0x10, 0x19, 0x2c, 0x7e, 0xdc, 0x53, 0xfc, 0xd1, 0xe1, 0xe2, 0x0b,
-		0x9e, 0xe2, 0x1f, 0xfb, 0x40, 0x04, 0xcd, 0x43, 0x42, 0x14, 0xaf, 0xe7, 0x9f, 0x95, 0xbf, 0xfe,
-		0xf5, 0xaf, 0x7f, 0x3d, 0x5a, 0xf8, 0x0e, 0x98, 0x6f, 0x9a, 0x9d, 0xc1, 0xa1, 0x29, 0xc8, 0x03,
-		0x67, 0x57, 0xac, 0x2b, 0xd2, 0x73, 0x0f, 0x71, 0xa0, 0x1d, 0xb3, 0xad, 0x19, 0x3b, 0xcb, 0x66,
-		0x6f, 0xc7, 0xbd, 0x48, 0x42, 0xfc, 0x10, 0xcb, 0x73, 0x9d, 0xa4, 0xbb, 0xf5, 0x57, 0x92, 0xf4,
-		0x89, 0x40, 0xf0, 0xf2, 0x46, 0xe1, 0xa7, 0x03, 0xd9, 0xcb, 0x0c, 0x71, 0x43, 0x0c, 0xbc, 0x82,
-		0xb7, 0xdb, 0xb8, 0x49, 0x46, 0x07, 0xfe, 0xf8, 0x01, 0x58, 0xd8, 0x31, 0x77, 0x4c, 0x4a, 0xe9,
-		0x0c, 0xf9, 0xc5, 0x6f, 0xa2, 0xc4, 0x9d, 0xdc, 0xec, 0xc4, 0x6b, 0x2b, 0xab, 0x55, 0x98, 0xe7,
-		0xc0, 0x2a, 0x75, 0x8b, 0xd8, 0xf6, 0x3a, 0x3a, 0xf0, 0x88, 0x56, 0xe6, 0xe7, 0xff, 0x90, 0xc6,
-		0xb3, 0x94, 0x39, 0x8e, 0x4a, 0xca, 0xd8, 0x0e, 0xfc, 0xaa, 0x02, 0x47, 0x7c, 0xf4, 0x98, 0x4b,
-		0x8a, 0x7b, 0x13, 0x28, 0xfe, 0x2b, 0x4e, 0x71, 0xde, 0x43, 0xb1, 0xce, 0x51, 0x57, 0x8b, 0x30,
-		0x7b, 0x18, 0x5a, 0xff, 0x9a, 0xd3, 0x4a, 0x62, 0x2f, 0x91, 0xcb, 0x90, 0xa6, 0x44, 0x9a, 0x7d,
-		0xcb, 0x36, 0x3b, 0xd4, 0xdf, 0x3f, 0x98, 0xcc, 0xbf, 0xf9, 0x43, 0xa6, 0x55, 0x53, 0x04, 0xad,
-		0xe8, 0x60, 0xad, 0xae, 0x02, 0x75, 0xef, 0x5a, 0xb8, 0xd9, 0x9e, 0x40, 0xe1, 0x37, 0x78, 0x43,
-		0x1c, 0xf8, 0xd5, 0x6b, 0xc4, 0xda, 0xef, 0x77, 0xa8, 0x3b, 0xee, 0x6d, 0xc9, 0xe4, 0xf3, 0x5c,
-		0x99, 0xdf, 0x7e, 0x2f, 0x53, 0xdc, 0xf3, 0x0e, 0x01, 0x4f, 0x9b, 0x3c, 0xa3, 0xb8, 0x83, 0x6d,
-		0x1b, 0xf7, 0x2c, 0x55, 0x6b, 0x8f, 0x6a, 0x9e, 0xe7, 0x40, 0x4c, 0xe6, 0x47, 0xbe, 0xea, 0x1f,
-		0xc5, 0xcb, 0x0c, 0x33, 0xdf, 0x6e, 0xaf, 0x6e, 0xc2, 0xb1, 0x11, 0x52, 0x31, 0x05, 0xcd, 0x1f,
-		0xe5, 0x34, 0x17, 0x86, 0x24, 0x83, 0x90, 0xdd, 0x00, 0x91, 0xef, 0x8c, 0xe5, 0x14, 0x34, 0x3f,
-		0xcc, 0x69, 0x22, 0x8e, 0x2b, 0x86, 0x94, 0x50, 0xbc, 0x0a, 0x73, 0x37, 0x71, 0x6f, 0xcb, 0xb4,
-		0xf8, 0x21, 0xa4, 0x29, 0xc8, 0x7d, 0x84, 0x93, 0x4b, 0x73, 0x44, 0x7a, 0x2a, 0x89, 0xd0, 0xba,
-		0x00, 0xb1, 0x6d, 0xad, 0x89, 0xa7, 0x20, 0x71, 0x8b, 0x93, 0x88, 0x12, 0x78, 0x82, 0x9a, 0x87,
-		0xe4, 0x8e, 0xc9, 0x23, 0x32, 0x93, 0xd1, 0x3f, 0xca, 0xd1, 0x13, 0x02, 0x87, 0x93, 0xe8, 0x9a,
-		0xdd, 0x7e, 0x5b, 0xb3, 0xa7, 0x69, 0xc1, 0x8f, 0x09, 0x12, 0x02, 0x87, 0x93, 0x38, 0x04, 0x5b,
-		0x3f, 0x26, 0x48, 0x58, 0x1e, 0x7e, 0x3e, 0x09, 0x09, 0xd3, 0x68, 0xef, 0x9b, 0xc6, 0x34, 0x8d,
-		0xf8, 0x38, 0xa7, 0x00, 0x1c, 0x85, 0x10, 0xb8, 0x08, 0xf1, 0x69, 0x07, 0xe2, 0x27, 0xbe, 0x2a,
-		0xa6, 0x87, 0x18, 0x81, 0xcb, 0x90, 0x16, 0x0a, 0x4a, 0x37, 0x8d, 0x29, 0x48, 0xfc, 0x24, 0x27,
-		0x91, 0xf2, 0xa0, 0xf1, 0x6e, 0xd8, 0xd8, 0xb2, 0x77, 0xf0, 0x34, 0x44, 0x3e, 0x29, 0xba, 0xc1,
-		0x51, 0x38, 0x2b, 0xb7, 0xb0, 0xd1, 0xdc, 0x9d, 0x8e, 0xc2, 0xa7, 0x04, 0x2b, 0x05, 0x0e, 0x21,
-		0x51, 0x84, 0xd9, 0x8e, 0xd6, 0xb3, 0x76, 0xb5, 0xf6, 0x54, 0xc3, 0xf1, 0x53, 0x9c, 0x46, 0xd2,
-		0x41, 0xe2, 0x1c, 0xe9, 0x1b, 0x87, 0x21, 0xf3, 0xd3, 0x82, 0x23, 0x1e, 0x34, 0x3e, 0xf5, 0x2c,
-		0x9b, 0x1a, 0xdc, 0x87, 0xa1, 0xf6, 0x33, 0x62, 0xea, 0x31, 0xdc, 0x75, 0x2f, 0xc5, 0x8b, 0x10,
-		0xb7, 0xf4, 0x17, 0xa7, 0x22, 0xf3, 0xb3, 0x62, 0xa4, 0x29, 0x02, 0x41, 0xbe, 0x0e, 0xc7, 0x47,
-		0x2e, 0x13, 0x53, 0x10, 0xfb, 0x39, 0x4e, 0xec, 0xe8, 0x88, 0xa5, 0x82, 0xab, 0x84, 0xc3, 0x92,
-		0xfc, 0x07, 0x42, 0x25, 0xe0, 0x01, 0x5a, 0x1b, 0xb0, 0xd0, 0x37, 0x2c, 0x6d, 0xfb, 0x70, 0x5c,
-		0xfb, 0x87, 0x82, 0x6b, 0x0c, 0xd7, 0xc7, 0xb5, 0x06, 0x1c, 0xe5, 0x14, 0x0f, 0x37, 0xae, 0x9f,
-		0x16, 0x8a, 0x95, 0x61, 0x6f, 0xfa, 0x47, 0xf7, 0x5b, 0x20, 0xeb, 0xb0, 0x53, 0x58, 0xc7, 0x96,
-		0xda, 0xd1, 0xba, 0x53, 0x50, 0xfe, 0x79, 0x4e, 0x59, 0x68, 0x7c, 0xc7, 0xbc, 0xb6, 0xd6, 0xb5,
-		0x2e, 0x21, 0xfe, 0x2c, 0x64, 0x04, 0xf1, 0xbe, 0xd1, 0xc3, 0x4d, 0x73, 0xc7, 0xd0, 0x5f, 0xc4,
-		0xad, 0x29, 0x48, 0x7f, 0x66, 0x60, 0xa8, 0x36, 0x3d, 0xe8, 0x84, 0x72, 0x05, 0x64, 0xc7, 0x56,
-		0x51, 0xf5, 0x0e, 0xdd, 0xb8, 0x3a, 0x98, 0xe2, 0x2f, 0x88, 0x91, 0x72, 0xf0, 0x2a, 0x14, 0x6d,
-		0xb5, 0x0c, 0xec, 0x1a, 0xc3, 0xb4, 0x22, 0xf9, 0x59, 0x4e, 0x68, 0xd6, 0xc5, 0xe2, 0x8a, 0xa3,
-		0x69, 0x76, 0xba, 0x5a, 0x6f, 0x1a, 0xfd, 0xf7, 0x8f, 0x84, 0xe2, 0xe0, 0x28, 0x5c, 0x71, 0x10,
-		0x8b, 0x8e, 0xac, 0xf6, 0x53, 0x50, 0xf8, 0x45, 0xa1, 0x38, 0x04, 0x0e, 0x27, 0x21, 0x0c, 0x86,
-		0x29, 0x48, 0xfc, 0x92, 0x20, 0x21, 0x70, 0x08, 0x89, 0xa7, 0xdd, 0x85, 0xb6, 0x87, 0x77, 0x74,
-		0xcb, 0xe6, 0x17, 0x8d, 0x0e, 0x26, 0xf5, 0xcb, 0x5f, 0xf5, 0x1b, 0x61, 0x8a, 0x07, 0x95, 0x68,
-		0x22, 0x1e, 0x41, 0xa5, 0x3b, 0x04, 0x93, 0x1b, 0xf6, 0x2b, 0x42, 0x13, 0x79, 0xd0, 0x48, 0xdb,
-		0x3c, 0x16, 0x22, 0x61, 0x7b, 0x93, 0x78, 0x92, 0x53, 0x90, 0xfb, 0xc7, 0x03, 0x8d, 0xab, 0x0b,
-		0x5c, 0x42, 0xd3, 0x63, 0xff, 0xf4, 0x8d, 0x1b, 0x78, 0x7f, 0x2a, 0xe9, 0xfc, 0x27, 0x03, 0xf6,
-		0xcf, 0x26, 0xc3, 0x64, 0x3a, 0x24, 0x3d, 0x60, 0x4f, 0xa1, 0x49, 0xb7, 0x10, 0x33, 0xdf, 0xf9,
-		0x26, 0xef, 0xaf, 0xdf, 0x9c, 0x5a, 0x5d, 0x23, 0x42, 0xee, 0x37, 0x7a, 0x26, 0x13, 0x7b, 0xef,
-		0x9b, 0x8e, 0x9c, 0xfb, 0x6c, 0x9e, 0xd5, 0x4b, 0x30, 0xeb, 0x33, 0x78, 0x26, 0x93, 0x7a, 0x1f,
-		0x27, 0x95, 0xf4, 0xda, 0x3b, 0xab, 0xe7, 0x20, 0x44, 0x8c, 0x97, 0xc9, 0xe8, 0xdf, 0xcd, 0xd1,
-		0x29, 0xf8, 0xea, 0x13, 0x10, 0x13, 0x46, 0xcb, 0x64, 0xd4, 0xef, 0xe1, 0xa8, 0x0e, 0x0a, 0x41,
-		0x17, 0x06, 0xcb, 0x64, 0xf4, 0xbf, 0x23, 0xd0, 0x05, 0x0a, 0x41, 0x9f, 0x9e, 0x85, 0xbf, 0xf6,
-		0xfe, 0x10, 0x5f, 0x74, 0x04, 0xef, 0x2e, 0x42, 0x94, 0x5b, 0x2a, 0x93, 0xb1, 0xbf, 0x97, 0x57,
-		0x2e, 0x30, 0x56, 0x1f, 0x83, 0xf0, 0x94, 0x0c, 0xff, 0x00, 0x47, 0x65, 0xf0, 0xab, 0x45, 0x48,
-		0x78, 0xac, 0x93, 0xc9, 0xe8, 0xdf, 0xcf, 0xd1, 0xbd, 0x58, 0xa4, 0xe9, 0xdc, 0x3a, 0x99, 0x4c,
-		0xe0, 0xef, 0x8a, 0xa6, 0x73, 0x0c, 0xc2, 0x36, 0x61, 0x98, 0x4c, 0xc6, 0xfe, 0xa0, 0xe0, 0xba,
-		0x40, 0x59, 0x7d, 0x12, 0xe2, 0xce, 0x62, 0x33, 0x19, 0xff, 0x07, 0x38, 0xbe, 0x8b, 0x43, 0x38,
-		0xe0, 0x59, 0xec, 0x26, 0x93, 0xf8, 0x7b, 0x82, 0x03, 0x1e, 0x2c, 0x32, 0x8d, 0x06, 0x0d, 0x98,
-		0xc9, 0x94, 0x3e, 0x24, 0xa6, 0xd1, 0x80, 0xfd, 0x42, 0x46, 0x93, 0xea, 0xfc, 0xc9, 0x24, 0x7e,
-		0x50, 0x8c, 0x26, 0x85, 0x27, 0xcd, 0x18, 0xb4, 0x08, 0x26, 0xd3, 0xf8, 0x61, 0xd1, 0x8c, 0x01,
-		0x83, 0x60, 0x75, 0x03, 0xd0, 0xb0, 0x35, 0x30, 0x99, 0xde, 0xab, 0x9c, 0xde, 0xdc, 0x90, 0x31,
-		0xb0, 0xfa, 0x0c, 0x1c, 0x1d, 0x6d, 0x09, 0x4c, 0xa6, 0xfa, 0x23, 0x6f, 0x0e, 0xf8, 0x6e, 0x5e,
-		0x43, 0x60, 0xb5, 0xe1, 0x2e, 0x29, 0x5e, 0x2b, 0x60, 0x32, 0xd9, 0x1f, 0x7d, 0xd3, 0xaf, 0xb8,
-		0xbd, 0x46, 0xc0, 0x6a, 0x1e, 0xc0, 0x5d, 0x80, 0x27, 0xd3, 0xfa, 0x08, 0xa7, 0xe5, 0x41, 0x22,
-		0x53, 0x83, 0xaf, 0xbf, 0x93, 0xf1, 0x6f, 0x89, 0xa9, 0xc1, 0x31, 0xc8, 0xd4, 0x10, 0x4b, 0xef,
-		0x64, 0xec, 0x8f, 0x8a, 0xa9, 0x21, 0x50, 0x88, 0x64, 0x7b, 0x56, 0xb7, 0xc9, 0x14, 0x3e, 0x2e,
-		0x24, 0xdb, 0x83, 0xb5, 0x5a, 0x85, 0xb9, 0xa1, 0x05, 0x71, 0x32, 0xa9, 0x4f, 0x70, 0x52, 0xf2,
-		0xe0, 0x7a, 0xe8, 0x5d, 0xbc, 0xf8, 0x62, 0x38, 0x99, 0xda, 0x8f, 0x0f, 0x2c, 0x5e, 0x7c, 0x2d,
-		0x5c, 0xbd, 0x08, 0x31, 0xa3, 0xdf, 0x6e, 0x93, 0xc9, 0x83, 0x0e, 0xbe, 0x68, 0x9a, 0xf9, 0xd2,
-		0xd7, 0x38, 0x77, 0x04, 0xc2, 0xea, 0x39, 0x08, 0xe3, 0xce, 0x16, 0x6e, 0x4d, 0xc2, 0xfc, 0xf2,
-		0xd7, 0x84, 0xc2, 0x24, 0xd0, 0xab, 0x4f, 0x02, 0xb0, 0xd0, 0x08, 0x3d, 0xac, 0x3d, 0x01, 0xf7,
-		0x2b, 0x5f, 0xe3, 0x37, 0xbb, 0x5c, 0x14, 0x97, 0x00, 0xbb, 0x27, 0x76, 0x30, 0x81, 0xaf, 0xfa,
-		0x09, 0xd0, 0x11, 0xb9, 0x00, 0xd1, 0xe7, 0x2d, 0xd3, 0xb0, 0xb5, 0x9d, 0x49, 0xd8, 0x7f, 0xcc,
-		0xb1, 0x05, 0x3c, 0x61, 0x58, 0xc7, 0xec, 0x61, 0x5b, 0xdb, 0xb1, 0x26, 0xe1, 0xfe, 0x37, 0x8e,
-		0xeb, 0x20, 0x10, 0xe4, 0xa6, 0x66, 0xd9, 0xd3, 0xf4, 0xfb, 0x4f, 0x04, 0xb2, 0x40, 0x20, 0x8d,
-		0x26, 0xbf, 0x6f, 0xe0, 0xfd, 0x49, 0xb8, 0x7f, 0x2a, 0x1a, 0xcd, 0xe1, 0x57, 0x9f, 0x80, 0x38,
-		0xf9, 0xc9, 0xae, 0x6b, 0x4e, 0x40, 0xfe, 0x33, 0x8e, 0xec, 0x62, 0x90, 0x9a, 0x2d, 0xbb, 0x65,
-		0xeb, 0x93, 0x99, 0xfd, 0xe7, 0x7c, 0xa4, 0x05, 0xfc, 0x6a, 0x1e, 0x12, 0x96, 0xdd, 0x6a, 0xf5,
-		0xb9, 0x7d, 0x3a, 0x01, 0xfd, 0x2f, 0xbe, 0xe6, 0x84, 0x2c, 0x1c, 0x1c, 0x32, 0xda, 0x2f, 0xdc,
-		0xb0, 0xbb, 0x26, 0x3d, 0xde, 0x33, 0x89, 0xc2, 0x9b, 0x9c, 0x82, 0x07, 0x65, 0xb5, 0x08, 0x49,
-		0xd2, 0x17, 0x71, 0x4a, 0x62, 0x12, 0x89, 0xbf, 0xe4, 0x0c, 0xf0, 0x21, 0x15, 0xbe, 0xfd, 0x37,
-		0xbe, 0x70, 0x52, 0xfa, 0xfc, 0x17, 0x4e, 0x4a, 0xff, 0xf5, 0x0b, 0x27, 0xa5, 0x0f, 0x7e, 0xf1,
-		0xe4, 0xcc, 0xe7, 0xbf, 0x78, 0x72, 0xe6, 0x77, 0xbf, 0x78, 0x72, 0x66, 0x74, 0x94, 0x18, 0x2e,
-		0x9b, 0x97, 0x4d, 0x16, 0x1f, 0x7e, 0xee, 0x9e, 0x1d, 0xdd, 0xde, 0xed, 0x6f, 0x2d, 0x37, 0xcd,
-		0xce, 0x99, 0xa6, 0x69, 0x75, 0x4c, 0xeb, 0x8c, 0x3f, 0xae, 0x4b, 0x7f, 0xc1, 0xff, 0x92, 0x88,
-		0xcf, 0xec, 0x0f, 0xe7, 0x6a, 0xc6, 0xfe, 0xb8, 0xe7, 0x87, 0xce, 0x43, 0x30, 0x6f, 0xec, 0xa3,
-		0xe3, 0x4c, 0xc1, 0xa9, 0xfd, 0x5e, 0x9b, 0xdf, 0x19, 0x8c, 0x92, 0xf4, 0x66, 0xaf, 0xed, 0x3f,
-		0x2f, 0x9e, 0xe4, 0xe7, 0xc5, 0x0b, 0xdf, 0x2f, 0x1d, 0xae, 0x27, 0xb1, 0xbc, 0xb1, 0x4f, 0x3b,
-		0xb2, 0x21, 0x3d, 0xf7, 0xe0, 0xc4, 0x38, 0xf7, 0x0d, 0xc3, 0x7c, 0xc1, 0x20, 0xcd, 0xee, 0x6e,
-		0x89, 0x18, 0xf7, 0xc9, 0xc1, 0x18, 0xf7, 0x33, 0xb8, 0xdd, 0x7e, 0x8a, 0xc0, 0x35, 0x08, 0xca,
-		0x56, 0x84, 0x5d, 0x4f, 0x87, 0x0f, 0x05, 0xe0, 0xe4, 0x50, 0x38, 0x9b, 0x0b, 0xc1, 0x38, 0x26,
-		0xac, 0x42, 0xac, 0x24, 0x64, 0x2b, 0x03, 0x51, 0x0b, 0x37, 0x4d, 0xa3, 0xc5, 0x0e, 0xfe, 0x06,
-		0x15, 0x91, 0x24, 0x8c, 0x30, 0x34, 0xc3, 0xb4, 0xf8, 0xad, 0x5b, 0x96, 0x28, 0x7c, 0xf8, 0x90,
-		0x8c, 0x98, 0x15, 0x35, 0x09, 0x6e, 0x9c, 0x9d, 0x92, 0x1b, 0xa2, 0x13, 0xbe, 0xc8, 0xff, 0xb4,
-		0x5c, 0xf9, 0xe1, 0x00, 0x2c, 0x0e, 0x72, 0x85, 0xcc, 0x2c, 0xcb, 0xd6, 0x3a, 0xdd, 0x71, 0x6c,
-		0xb9, 0x08, 0xf1, 0x86, 0x80, 0x39, 0x34, 0x5f, 0x6e, 0x1d, 0x92, 0x2f, 0x29, 0xa7, 0x2a, 0xc1,
-		0x98, 0x95, 0x29, 0x19, 0xe3, 0xf4, 0xe3, 0xb6, 0x38, 0xf3, 0x3f, 0x23, 0x70, 0x9c, 0x4d, 0x27,
-		0x95, 0x4d, 0x25, 0x96, 0xe0, 0x3c, 0x49, 0x7a, 0x8b, 0x26, 0xef, 0x93, 0xe4, 0x9e, 0x82, 0xf9,
-		0x0a, 0xd1, 0x16, 0xc4, 0x0b, 0x72, 0x77, 0x78, 0x46, 0x5e, 0x4c, 0x5e, 0xf2, 0x19, 0xfc, 0x7c,
-		0x27, 0xd0, 0x9b, 0x95, 0xfb, 0x4e, 0x09, 0xe4, 0x7a, 0x53, 0x6b, 0x6b, 0xbd, 0x6f, 0x94, 0x14,
-		0x7a, 0x0c, 0x80, 0x1d, 0x2b, 0x73, 0x9e, 0x14, 0x4a, 0xad, 0x64, 0x96, 0xbd, 0x9d, 0x5b, 0x66,
-		0x35, 0xd1, 0x4b, 0x3b, 0x71, 0x0a, 0x4b, 0x7e, 0x9e, 0x7e, 0x16, 0xc0, 0x2d, 0x40, 0x27, 0xe0,
-		0x58, 0xbd, 0x98, 0x5f, 0xcb, 0x2b, 0xe2, 0xc4, 0x4d, 0x7d, 0xa3, 0x5c, 0x64, 0x2f, 0x7c, 0xcc,
-		0xa0, 0xa3, 0x80, 0xbc, 0x85, 0xce, 0x45, 0x87, 0x23, 0x30, 0xe7, 0xcd, 0x67, 0xcf, 0x2d, 0x04,
-		0x88, 0xa5, 0xa8, 0x77, 0xba, 0x6d, 0x4c, 0xb7, 0x86, 0x55, 0x5d, 0x70, 0x6d, 0xb2, 0x11, 0xf2,
-		0x9b, 0xff, 0x91, 0x5d, 0xc1, 0x9f, 0x77, 0xd1, 0x1d, 0x9e, 0xaf, 0xae, 0xc1, 0x9c, 0xd6, 0x6c,
-		0xe2, 0xae, 0x8f, 0xe4, 0x04, 0x55, 0x4d, 0x08, 0xd2, 0xcd, 0x6e, 0x8e, 0xe9, 0x52, 0x7b, 0x0c,
-		0x22, 0x16, 0xed, 0xfd, 0x24, 0x12, 0x9f, 0xe3, 0x24, 0x38, 0xf8, 0xaa, 0x01, 0x73, 0xec, 0xc5,
-		0x19, 0xec, 0x69, 0xc6, 0xc1, 0x71, 0x86, 0x7f, 0xfa, 0x0b, 0x0f, 0xd3, 0x3d, 0xe8, 0xbb, 0xfc,
-		0xc3, 0x32, 0x42, 0x9c, 0x14, 0x99, 0xd3, 0x76, 0x1b, 0x8a, 0x21, 0x25, 0xea, 0xe3, 0x0d, 0x3e,
-		0xb8, 0xb2, 0x5f, 0xe5, 0x95, 0x9d, 0x1c, 0x25, 0x03, 0x9e, 0x9a, 0x66, 0x39, 0x55, 0x56, 0x50,
-		0x28, 0x8f, 0x9b, 0xd3, 0xcf, 0x3d, 0x30, 0xbc, 0x3a, 0xb1, 0x7f, 0x0f, 0x51, 0xca, 0x17, 0xbd,
-		0xd5, 0x38, 0x73, 0xef, 0xc3, 0x21, 0x98, 0xd3, 0x3a, 0xba, 0x61, 0x9e, 0xa1, 0x7f, 0xf9, 0x9c,
-		0x0b, 0xd3, 0xc4, 0x14, 0x9b, 0x92, 0xe7, 0xd9, 0x54, 0x98, 0x2c, 0x31, 0x7f, 0xf6, 0x7d, 0x3f,
-		0x19, 0x76, 0xa7, 0xcb, 0xea, 0xfa, 0xf0, 0x91, 0xc2, 0xc9, 0x34, 0xfe, 0x5c, 0xd0, 0x18, 0x3c,
-		0x21, 0xb8, 0xfa, 0x4e, 0x88, 0x39, 0x64, 0x26, 0x59, 0x26, 0x82, 0x88, 0x83, 0x41, 0xec, 0x12,
-		0x36, 0x33, 0xa7, 0xb1, 0x42, 0xdf, 0x14, 0xf8, 0x6c, 0x86, 0x56, 0x49, 0x6f, 0x2e, 0x43, 0xaa,
-		0x65, 0x1a, 0xb6, 0x6a, 0x76, 0x74, 0x1b, 0x77, 0xba, 0xf6, 0x44, 0xbb, 0xee, 0x2f, 0x19, 0x91,
-		0x98, 0x32, 0x4b, 0xf0, 0x6a, 0x02, 0x8d, 0xb4, 0x84, 0x3d, 0x38, 0x33, 0x4d, 0x4b, 0xfe, 0xbb,
-		0xd3, 0x12, 0x8a, 0x43, 0x5a, 0x72, 0x5b, 0xd2, 0x61, 0xb5, 0x6e, 0x70, 0x65, 0x6e, 0xef, 0x31,
-		0x29, 0x70, 0xa4, 0xe3, 0x5f, 0x84, 0xe0, 0x24, 0x07, 0xde, 0xd2, 0x2c, 0x7c, 0xe6, 0xe6, 0xd9,
-		0x2d, 0x6c, 0x6b, 0x67, 0xcf, 0x34, 0x4d, 0x5d, 0xac, 0xe4, 0xf3, 0x5c, 0x59, 0x93, 0xf2, 0x65,
-		0x5e, 0x9e, 0x1d, 0xb9, 0xdd, 0x9d, 0x1d, 0xaf, 0xe4, 0xb3, 0xc3, 0x32, 0x98, 0x6b, 0x43, 0xa8,
-		0x68, 0xea, 0xf4, 0xb2, 0x5c, 0x0b, 0x1b, 0x66, 0x87, 0xab, 0x5b, 0x96, 0x40, 0x57, 0x20, 0xa2,
-		0x75, 0xcc, 0xbe, 0x61, 0x33, 0x55, 0x5b, 0x78, 0xf8, 0x37, 0x5e, 0x5b, 0x9c, 0xf9, 0xcf, 0xaf,
-		0x2d, 0x1e, 0x61, 0x64, 0xad, 0xd6, 0x8d, 0x65, 0xdd, 0x3c, 0xd3, 0xd1, 0xec, 0x5d, 0x32, 0x7d,
-		0x7f, 0xe7, 0xb3, 0x0f, 0x01, 0xaf, 0xaf, 0x62, 0xd8, 0x9f, 0x7a, 0xfd, 0xd3, 0xa7, 0x25, 0x85,
-		0xe3, 0xaf, 0x86, 0xde, 0xf8, 0xd8, 0xa2, 0x94, 0xeb, 0x42, 0xb4, 0x84, 0x9b, 0x07, 0x54, 0x58,
-		0x19, 0xa8, 0xf0, 0x2c, 0xaf, 0xf0, 0xc4, 0x70, 0x85, 0xec, 0x12, 0x4e, 0x09, 0x37, 0x3d, 0xd5,
-		0x96, 0x70, 0x73, 0xa0, 0xc6, 0x0a, 0xc4, 0x2a, 0x86, 0xcd, 0x5e, 0xcd, 0x78, 0x02, 0x82, 0xba,
-		0xc1, 0x2e, 0x5b, 0xc7, 0x0b, 0x0f, 0x1c, 0xa2, 0x2b, 0x0a, 0xc1, 0xcb, 0xd5, 0x20, 0x56, 0xc2,
-		0x4d, 0x46, 0xaa, 0x08, 0xc1, 0x16, 0x6e, 0x72, 0x52, 0xb7, 0xd1, 0x48, 0x82, 0x5d, 0x28, 0xfd,
-		0xee, 0x1f, 0x9c, 0x9c, 0x79, 0xe9, 0x0b, 0x27, 0x67, 0xc6, 0x8a, 0x53, 0x6e, 0xb2, 0x38, 0x39,
-		0x52, 0xf4, 0x93, 0x21, 0xb8, 0x93, 0x3e, 0xbb, 0xd4, 0xeb, 0xe8, 0x86, 0x7d, 0xa6, 0xd9, 0xdb,
-		0xef, 0xda, 0x26, 0x51, 0x2a, 0xe6, 0x36, 0x17, 0xa2, 0x39, 0xb7, 0x78, 0x99, 0x15, 0x8f, 0x16,
-		0xa1, 0xdc, 0x36, 0x84, 0x37, 0x08, 0x1e, 0x19, 0x24, 0xdb, 0xb4, 0xb5, 0x36, 0xb7, 0x84, 0x58,
-		0x82, 0xe4, 0xb2, 0xa7, 0x9a, 0x02, 0x2c, 0x57, 0x17, 0xaf, 0x34, 0xb5, 0xb1, 0xb6, 0xcd, 0x5e,
-		0xbc, 0x08, 0x52, 0x13, 0x3a, 0x46, 0x32, 0xe8, 0xe3, 0x16, 0x0b, 0x10, 0xd6, 0xfa, 0xec, 0xb4,
-		0x55, 0x90, 0xd8, 0xd6, 0x34, 0x91, 0x7b, 0x0a, 0xa2, 0x7c, 0x4f, 0x1f, 0xc9, 0x10, 0xbc, 0x81,
-		0xf7, 0x69, 0x3d, 0x49, 0x85, 0xfc, 0x44, 0xcb, 0x10, 0xa6, 0x8d, 0xe7, 0x17, 0x8d, 0x32, 0xcb,
-		0x43, 0xad, 0x5f, 0xa6, 0x8d, 0x54, 0x18, 0x58, 0xee, 0x2a, 0xc4, 0x4a, 0x26, 0x91, 0x6c, 0x3f,
-		0xb5, 0x38, 0xa3, 0x46, 0xdb, 0xdc, 0xed, 0xdb, 0xe2, 0x32, 0x28, 0x4d, 0xa0, 0xa3, 0x10, 0x61,
-		0x2f, 0xa0, 0xf0, 0x13, 0x63, 0x3c, 0x95, 0x2b, 0x42, 0x94, 0xd2, 0xae, 0x75, 0x9d, 0x67, 0xc5,
-		0x24, 0xcf, 0xb3, 0x62, 0x9c, 0x7c, 0xc0, 0x6d, 0x2c, 0x82, 0x50, 0x4b, 0xb3, 0x35, 0xde, 0x6f,
-		0xfa, 0x3b, 0xf7, 0x2e, 0x88, 0x71, 0x22, 0x16, 0x5a, 0x81, 0xa0, 0xd9, 0x15, 0x07, 0x22, 0xb3,
-		0xe3, 0xba, 0x52, 0xeb, 0x16, 0x42, 0x44, 0x96, 0x14, 0x02, 0x5c, 0xa8, 0x8e, 0x15, 0x8b, 0x47,
-		0x7d, 0x62, 0xd1, 0xc1, 0xf6, 0xd6, 0xb6, 0xed, 0xfe, 0x60, 0xc3, 0x39, 0x24, 0x0a, 0x8e, 0xa0,
-		0xdc, 0x0a, 0xc0, 0x49, 0x4f, 0xe9, 0x4d, 0xdc, 0xb3, 0x74, 0xd3, 0x60, 0xd2, 0xc4, 0x25, 0x05,
-		0x79, 0x1a, 0xc8, 0xcb, 0xc7, 0x88, 0xca, 0x13, 0x10, 0xcc, 0x77, 0xbb, 0x28, 0x0b, 0x31, 0x9a,
-		0x6e, 0x9a, 0x4c, 0x56, 0x42, 0x8a, 0x93, 0x26, 0x65, 0x96, 0xb9, 0x6d, 0xbf, 0xa0, 0xf5, 0x9c,
-		0x07, 0xc2, 0x44, 0x3a, 0x77, 0x01, 0xe2, 0x45, 0xd3, 0xb0, 0xb0, 0x61, 0xf5, 0xa9, 0x7d, 0xbd,
-		0xd5, 0x36, 0x9b, 0x37, 0x38, 0x05, 0x96, 0x20, 0xcc, 0xd6, 0xba, 0x5d, 0x8a, 0x19, 0x52, 0xc8,
-		0x4f, 0x36, 0xb3, 0x0b, 0xb5, 0xb1, 0xec, 0x39, 0x77, 0x38, 0xf6, 0xf0, 0x0e, 0xba, 0x86, 0xb2,
-		0x04, 0x77, 0x0c, 0x4f, 0xa4, 0x1b, 0x78, 0xdf, 0x3a, 0xec, 0x3c, 0x7a, 0x16, 0xe2, 0x1b, 0xf4,
-		0x99, 0xd6, 0xa7, 0xf0, 0x3e, 0xca, 0x42, 0x14, 0xb7, 0x56, 0xce, 0x9d, 0x3b, 0x7b, 0x81, 0x49,
-		0xf9, 0x95, 0x19, 0x45, 0x64, 0xa0, 0x93, 0x10, 0xb7, 0x70, 0xb3, 0xbb, 0x72, 0xee, 0xfc, 0x8d,
-		0xb3, 0x4c, 0xac, 0xae, 0xcc, 0x28, 0x6e, 0xd6, 0x6a, 0x8c, 0xf4, 0xf8, 0x8d, 0x8f, 0x2f, 0x4a,
-		0x85, 0x30, 0x04, 0xad, 0x7e, 0xe7, 0x9b, 0x26, 0x1b, 0x7f, 0x1a, 0x81, 0x25, 0x4f, 0x29, 0x5b,
-		0xb0, 0xf8, 0x8d, 0x08, 0xe7, 0x69, 0x5f, 0xd9, 0xd3, 0x7f, 0x0a, 0x31, 0x66, 0x25, 0x3a, 0x90,
-		0x8b, 0xb9, 0xcf, 0x48, 0x90, 0xbc, 0x26, 0x28, 0xd7, 0xb1, 0x8d, 0x2e, 0x02, 0x38, 0x35, 0x89,
-		0xa9, 0x72, 0x62, 0x79, 0xb0, 0xae, 0x65, 0x07, 0x47, 0xf1, 0x80, 0xa3, 0xc7, 0xa8, 0x00, 0x76,
-		0x4d, 0x8b, 0x3f, 0x16, 0x35, 0x01, 0xd5, 0x01, 0x46, 0x0f, 0x02, 0xa2, 0x5a, 0x4d, 0xbd, 0x69,
-		0xda, 0xba, 0xb1, 0xa3, 0x76, 0xcd, 0x17, 0xf8, 0x13, 0x7c, 0x41, 0x45, 0xa6, 0x25, 0xd7, 0x68,
-		0xc1, 0x06, 0xc9, 0x27, 0x8d, 0x8e, 0x3b, 0x54, 0x88, 0xab, 0xa8, 0xb5, 0x5a, 0x3d, 0x6c, 0x59,
-		0x5c, 0x71, 0x89, 0x24, 0xba, 0x08, 0xd1, 0x6e, 0x7f, 0x4b, 0x15, 0x5a, 0x22, 0xb1, 0x72, 0xc7,
-		0xa8, 0x39, 0x2f, 0x64, 0x83, 0xcf, 0xfa, 0x48, 0xb7, 0xbf, 0x45, 0x24, 0xe5, 0x2e, 0x48, 0x8e,
-		0x68, 0x4c, 0xe2, 0xa6, 0xdb, 0x0e, 0xfa, 0x32, 0x30, 0xef, 0x81, 0xda, 0xed, 0xe9, 0x66, 0x4f,
-		0xb7, 0xf7, 0xe9, 0xa1, 0xc9, 0xa0, 0x22, 0x8b, 0x82, 0x0d, 0x9e, 0x9f, 0xbb, 0x01, 0xe9, 0x3a,
-		0x75, 0x21, 0xdc, 0x96, 0x9f, 0x73, 0xdb, 0x27, 0x4d, 0x6e, 0xdf, 0xd8, 0x96, 0x05, 0x86, 0x5a,
-		0x76, 0xfa, 0x3f, 0x49, 0x90, 0x28, 0x90, 0x89, 0x5b, 0x29, 0x5d, 0x6a, 0x6b, 0x3b, 0xe8, 0x2c,
-		0x1c, 0x29, 0xac, 0xd5, 0x8a, 0x4f, 0xa9, 0x95, 0x92, 0x7a, 0x69, 0x2d, 0xef, 0x39, 0xd3, 0x9f,
-		0x3d, 0xfa, 0xca, 0xad, 0x25, 0xe4, 0x81, 0xdd, 0x34, 0xa8, 0x9f, 0x8b, 0xce, 0xc0, 0x82, 0x1f,
-		0x25, 0x5f, 0xa8, 0x97, 0xab, 0x0d, 0x59, 0xca, 0x1e, 0x79, 0xe5, 0xd6, 0xd2, 0x9c, 0x07, 0x23,
-		0xbf, 0x65, 0x61, 0xc3, 0x1e, 0x46, 0x28, 0xd6, 0xd6, 0xd7, 0x2b, 0x0d, 0x39, 0x30, 0x84, 0x50,
-		0x34, 0x3b, 0x1d, 0xdd, 0x46, 0xf7, 0xc3, 0x9c, 0x1f, 0xa1, 0x5a, 0x59, 0x93, 0x83, 0x59, 0xf4,
-		0xca, 0xad, 0xa5, 0x94, 0x07, 0xba, 0xaa, 0xb7, 0xb3, 0xb1, 0x97, 0x7f, 0xfc, 0xe4, 0xcc, 0xa7,
-		0xfe, 0xfe, 0x49, 0xa9, 0xb0, 0x3e, 0x76, 0xce, 0x3d, 0x72, 0xb8, 0x39, 0xe7, 0x5f, 0xb7, 0xbf,
-		0x76, 0x87, 0x4f, 0xdd, 0x70, 0x1b, 0xd1, 0xa3, 0x8c, 0xa7, 0x9d, 0x6e, 0x93, 0xe2, 0x1e, 0xd9,
-		0x83, 0xcd, 0x83, 0xec, 0x84, 0x45, 0x21, 0x3b, 0x51, 0x31, 0xe4, 0x2e, 0xc0, 0xec, 0x86, 0xd6,
-		0xb3, 0xeb, 0xd8, 0xbe, 0x82, 0xb5, 0x16, 0xee, 0xf9, 0xed, 0x87, 0x59, 0x61, 0x3f, 0x20, 0x08,
-		0x51, 0x23, 0x81, 0xad, 0x9f, 0xf4, 0x77, 0x6e, 0x17, 0x42, 0xf4, 0x52, 0x9d, 0x63, 0x5b, 0x70,
-		0x0c, 0x66, 0x5b, 0x90, 0x95, 0x61, 0xdf, 0xe6, 0x97, 0x8e, 0x93, 0x0a, 0x4b, 0xa0, 0x47, 0x85,
-		0x85, 0x10, 0x3c, 0xd8, 0x42, 0xe0, 0xd3, 0x8b, 0xdb, 0x09, 0x6d, 0x88, 0xf2, 0x21, 0x76, 0x1a,
-		0x22, 0xb9, 0x0d, 0x41, 0xeb, 0x90, 0xee, 0x6a, 0x3d, 0x9b, 0x3e, 0xd1, 0xb3, 0x4b, 0x7b, 0xc1,
-		0x67, 0xf0, 0xe2, 0xb0, 0x3e, 0xf1, 0x75, 0x96, 0xd7, 0x32, 0xdb, 0xf5, 0x66, 0xe6, 0xfe, 0x28,
-		0x04, 0x11, 0xce, 0x8c, 0x27, 0x20, 0xca, 0xd9, 0xca, 0xe7, 0xdc, 0x9d, 0xcb, 0xc3, 0xcb, 0xec,
-		0xb2, 0xb3, 0x1c, 0x72, 0x7a, 0x02, 0x07, 0xdd, 0x0b, 0xb1, 0xe6, 0xae, 0xa6, 0x1b, 0xaa, 0xde,
-		0xe2, 0xc6, 0x71, 0xe2, 0x0b, 0xaf, 0x2d, 0x46, 0x8b, 0x24, 0xaf, 0x52, 0x52, 0xa2, 0xb4, 0xb0,
-		0xd2, 0x22, 0x36, 0xcd, 0x2e, 0xd6, 0x77, 0x76, 0x6d, 0xae, 0x37, 0x78, 0x0a, 0x3d, 0x0e, 0x21,
-		0x22, 0x10, 0xfc, 0x5e, 0x41, 0x76, 0xc8, 0xeb, 0x71, 0xc2, 0x52, 0x85, 0x18, 0xa9, 0xf8, 0x83,
-		0xff, 0x65, 0x51, 0x52, 0x28, 0x06, 0x2a, 0xc2, 0x6c, 0x5b, 0xb3, 0x6c, 0x95, 0xae, 0xc7, 0xa4,
-		0x7a, 0x76, 0xa1, 0xe0, 0xf8, 0x30, 0x43, 0x38, 0x63, 0x79, 0xd3, 0x13, 0x04, 0x8b, 0x65, 0xb5,
-		0xd0, 0x29, 0x90, 0x29, 0x91, 0x26, 0x9d, 0x81, 0xcc, 0x4a, 0x8c, 0x50, 0xbe, 0xa7, 0x48, 0x3e,
-		0x9b, 0x98, 0xd4, 0x56, 0x3c, 0x01, 0x71, 0xfa, 0x0e, 0x15, 0x05, 0x61, 0x37, 0x39, 0x63, 0x24,
-		0x83, 0x16, 0xde, 0x07, 0x69, 0x57, 0xeb, 0x33, 0x90, 0x18, 0xa3, 0xe2, 0x66, 0x53, 0xc0, 0x87,
-		0x61, 0xc1, 0xc0, 0x7b, 0xb6, 0x3a, 0x08, 0x1d, 0xa7, 0xd0, 0x88, 0x94, 0x5d, 0xf3, 0x63, 0xdc,
-		0x03, 0xa9, 0xa6, 0x60, 0x3e, 0x83, 0x05, 0x0a, 0x3b, 0xeb, 0xe4, 0x52, 0xb0, 0xe3, 0x10, 0xd3,
-		0xba, 0x5d, 0x06, 0x90, 0xe0, 0x5a, 0xbf, 0xdb, 0xa5, 0x45, 0xa7, 0x61, 0x8e, 0xf6, 0xb1, 0x87,
-		0xad, 0x7e, 0xdb, 0xe6, 0x44, 0x92, 0x14, 0x26, 0x4d, 0x0a, 0x14, 0x96, 0x4f, 0x61, 0xef, 0x86,
-		0x59, 0x7c, 0x53, 0x6f, 0x61, 0xa3, 0x89, 0x19, 0xdc, 0x2c, 0x85, 0x4b, 0x8a, 0x4c, 0x0a, 0x74,
-		0x3f, 0x38, 0xda, 0x5c, 0x15, 0x2b, 0x4d, 0x8a, 0xd1, 0x13, 0xf9, 0x79, 0x96, 0x9d, 0xcb, 0x40,
-		0xa8, 0xa4, 0xd9, 0x1a, 0x31, 0x97, 0xec, 0x3d, 0xb6, 0x7c, 0x26, 0x15, 0xf2, 0x33, 0xf7, 0x4b,
-		0x41, 0x08, 0x5d, 0x33, 0x6d, 0x8c, 0x1e, 0xf1, 0x98, 0xb2, 0xa9, 0x51, 0xf2, 0x5c, 0xd7, 0x77,
-		0x0c, 0xdc, 0x5a, 0xb7, 0x76, 0x3c, 0x6f, 0xbf, 0xba, 0xe2, 0x14, 0xf0, 0x89, 0xd3, 0x02, 0x84,
-		0x7b, 0x66, 0xdf, 0x68, 0x89, 0xe3, 0xfb, 0x34, 0x81, 0xca, 0x10, 0x73, 0xa4, 0x24, 0x34, 0x49,
-		0x4a, 0xd2, 0x44, 0x4a, 0x88, 0x0c, 0xf3, 0x0c, 0x25, 0xba, 0xc5, 0x85, 0xa5, 0x00, 0x71, 0x47,
-		0x79, 0x71, 0x69, 0x9b, 0x4e, 0x60, 0x5d, 0x34, 0xb2, 0x44, 0x3a, 0x63, 0xef, 0x30, 0x8f, 0x49,
-		0x9c, 0xec, 0x14, 0x70, 0xee, 0xf9, 0xc4, 0x8a, 0xbf, 0x43, 0x1b, 0xa5, 0xfd, 0x72, 0xc5, 0x8a,
-		0xbd, 0x45, 0x7b, 0x07, 0xc4, 0x2d, 0x7d, 0xc7, 0xa0, 0x37, 0x62, 0xb8, 0xe4, 0xb9, 0x19, 0xa4,
-		0xd4, 0xbd, 0x0f, 0xcc, 0x24, 0xcd, 0xf3, 0xde, 0xf9, 0x19, 0x98, 0x77, 0x5f, 0x1a, 0x77, 0xa9,
-		0x30, 0x29, 0x43, 0x4e, 0x51, 0x5d, 0x94, 0xe4, 0x7e, 0x4d, 0x82, 0x08, 0x5f, 0xb1, 0xdc, 0x61,
-		0x90, 0x46, 0x0f, 0x43, 0x60, 0xdc, 0x30, 0x04, 0x6f, 0x7f, 0x18, 0xf2, 0x00, 0x4e, 0x33, 0x2d,
-		0xfe, 0xda, 0xe8, 0x08, 0xb3, 0x8a, 0x35, 0xb1, 0xae, 0xef, 0xf0, 0x79, 0xef, 0x41, 0xca, 0xfd,
-		0xbe, 0x44, 0x2c, 0x7c, 0x5e, 0x8e, 0xf2, 0x30, 0x2b, 0xda, 0xa5, 0x6e, 0xb7, 0xb5, 0x1d, 0x2e,
-		0x8a, 0x77, 0x8e, 0x6d, 0x1c, 0x59, 0x85, 0x95, 0x04, 0x6f, 0x0f, 0xb5, 0x27, 0x46, 0x0e, 0x6b,
-		0x60, 0xcc, 0xb0, 0xfa, 0xe4, 0x28, 0x78, 0x7b, 0x72, 0xe4, 0x1b, 0xf1, 0xd0, 0xc0, 0x88, 0xe7,
-		0xfe, 0x40, 0xe2, 0xef, 0x9c, 0xb7, 0xd8, 0xf5, 0x9f, 0xff, 0x53, 0x43, 0xf5, 0x1c, 0x97, 0xad,
-		0x16, 0x6e, 0xa9, 0x43, 0x63, 0x76, 0xf7, 0x30, 0x45, 0x7f, 0x9b, 0xdd, 0xb1, 0x43, 0x82, 0x4a,
-		0xdd, 0x1d, 0xc3, 0xcf, 0x06, 0x60, 0x6e, 0x08, 0xfe, 0x6f, 0xde, 0x58, 0xfa, 0x67, 0x6f, 0x78,
-		0xca, 0xd9, 0x1b, 0x19, 0x3b, 0x7b, 0x7f, 0x21, 0x40, 0x03, 0x00, 0x5d, 0xd3, 0xd2, 0xda, 0x7f,
-		0x1d, 0xba, 0xf7, 0x04, 0xc4, 0xbb, 0x66, 0x5b, 0x65, 0x25, 0xec, 0x02, 0x55, 0xac, 0x6b, 0xb6,
-		0x95, 0x21, 0x31, 0x0b, 0xbf, 0x45, 0x8a, 0x39, 0xf2, 0x16, 0x0c, 0x42, 0x74, 0x70, 0x42, 0xf5,
-		0x20, 0xc9, 0x58, 0xc1, 0xad, 0xa6, 0x87, 0x09, 0x0f, 0xa8, 0x19, 0x26, 0x0d, 0x5b, 0x79, 0xac,
-		0xd9, 0x0c, 0x52, 0xe1, 0x70, 0x04, 0x83, 0x19, 0x19, 0xa3, 0x22, 0x47, 0x5e, 0x8d, 0xa5, 0x70,
-		0xb8, 0xdc, 0x0f, 0x49, 0x00, 0x6b, 0x84, 0xb3, 0xb4, 0xbf, 0xc4, 0xde, 0xb1, 0x68, 0x13, 0x54,
-		0x5f, 0xcd, 0x27, 0xc7, 0x0d, 0x1a, 0xaf, 0x3f, 0x69, 0x79, 0xdb, 0x5d, 0x84, 0x59, 0x57, 0xb6,
-		0x2d, 0x2c, 0x1a, 0x73, 0xf2, 0x00, 0xaf, 0xb4, 0x8e, 0x6d, 0x25, 0x79, 0xd3, 0x93, 0xca, 0xfd,
-		0x73, 0x09, 0xe2, 0xb4, 0x4d, 0xeb, 0xd8, 0xd6, 0x7c, 0x63, 0x28, 0xdd, 0xfe, 0x18, 0xde, 0x09,
-		0xc0, 0xc8, 0x58, 0xfa, 0x8b, 0x98, 0x4b, 0x56, 0x9c, 0xe6, 0xd4, 0xf5, 0x17, 0x31, 0x3a, 0xef,
-		0x30, 0x3c, 0x78, 0x30, 0xc3, 0x85, 0xd7, 0xca, 0xd9, 0x7e, 0x0c, 0xa2, 0xf4, 0x1d, 0x89, 0x3d,
-		0x8b, 0x3b, 0xa2, 0x11, 0xa3, 0xdf, 0x69, 0xec, 0x59, 0xb9, 0xe7, 0x21, 0xda, 0xd8, 0x63, 0xf1,
-		0xc4, 0x13, 0x10, 0xef, 0x99, 0x26, 0xb7, 0xfe, 0x98, 0xd5, 0x1d, 0x23, 0x19, 0xd4, 0xd8, 0x11,
-		0x31, 0xb4, 0x80, 0x1b, 0x43, 0x73, 0x83, 0x80, 0xc1, 0xa9, 0x82, 0x80, 0xc4, 0xfb, 0x9c, 0xf5,
-		0xcd, 0x24, 0xf4, 0x20, 0x1c, 0xab, 0x57, 0x2e, 0x57, 0xcb, 0x25, 0x75, 0xbd, 0x7e, 0x79, 0xe0,
-		0xfe, 0x7c, 0x36, 0xfd, 0xca, 0xad, 0xa5, 0x04, 0x77, 0x3b, 0xc7, 0x41, 0x6f, 0x28, 0xe5, 0x6b,
-		0xb5, 0x46, 0x59, 0x96, 0x18, 0xf4, 0x46, 0x0f, 0xdf, 0x34, 0x6d, 0xf6, 0x11, 0x9c, 0x87, 0xe1,
-		0xf8, 0x08, 0x68, 0xc7, 0xf9, 0x9c, 0x7b, 0xe5, 0xd6, 0xd2, 0xec, 0x46, 0x0f, 0x33, 0x29, 0xa3,
-		0x18, 0xcb, 0x90, 0x19, 0xc6, 0xa8, 0x6d, 0xd4, 0xea, 0xf9, 0x35, 0x79, 0x29, 0x2b, 0xbf, 0x72,
-		0x6b, 0x29, 0x29, 0x54, 0x06, 0x81, 0xff, 0xe6, 0x7b, 0x9f, 0xdf, 0x1b, 0xf3, 0x45, 0x8d, 0x99,
-		0x5f, 0xd7, 0xd5, 0x7a, 0x5a, 0xe7, 0xb0, 0xee, 0xe7, 0x84, 0xc3, 0x08, 0xb9, 0xcf, 0x04, 0x20,
-		0xed, 0x38, 0x37, 0x1b, 0xb4, 0x06, 0xf4, 0x88, 0x37, 0xe2, 0x97, 0x18, 0xbb, 0x76, 0x30, 0x68,
-		0x11, 0x10, 0x7c, 0x27, 0xc4, 0x84, 0x91, 0xcc, 0x27, 0xd5, 0xd2, 0x88, 0xf5, 0x8d, 0x43, 0x70,
-		0x54, 0x07, 0x03, 0x3d, 0x09, 0x71, 0x67, 0x8a, 0x39, 0xaf, 0x87, 0x8f, 0x9f, 0x93, 0x1c, 0xdf,
-		0xc5, 0x41, 0x17, 0x5c, 0x37, 0x2e, 0x34, 0xce, 0x31, 0xbc, 0xc6, 0x00, 0x38, 0xb2, 0xe3, 0xc2,
-		0x3d, 0x0c, 0x21, 0x6d, 0xab, 0xa9, 0x73, 0x05, 0x7c, 0xc7, 0x30, 0x5e, 0xbe, 0x50, 0xac, 0x70,
-		0x24, 0x0a, 0x99, 0xab, 0xf0, 0x60, 0x0a, 0xe7, 0x17, 0x7d, 0x8f, 0x75, 0x4f, 0x65, 0xbe, 0x30,
-		0xb3, 0x2e, 0x62, 0x1d, 0x6d, 0xaf, 0x40, 0xdd, 0xe1, 0x63, 0x10, 0x25, 0x85, 0x3b, 0xfc, 0x61,
-		0xb4, 0xa0, 0x12, 0xe9, 0x68, 0x7b, 0x97, 0x35, 0xeb, 0x6a, 0x28, 0x16, 0x94, 0x43, 0xb9, 0x9f,
-		0x22, 0x96, 0x8a, 0x8f, 0x2b, 0xe8, 0x01, 0x40, 0x04, 0x43, 0xdb, 0xc1, 0x2a, 0x99, 0xba, 0x94,
-		0xbd, 0x82, 0x6e, 0xba, 0xa3, 0xed, 0xe5, 0x77, 0x70, 0xb5, 0xdf, 0xa1, 0x0d, 0xb0, 0xd0, 0x3a,
-		0xc8, 0x02, 0x58, 0x8c, 0x2c, 0x67, 0xff, 0xf1, 0xe1, 0xcf, 0xc9, 0x70, 0x00, 0xb6, 0x00, 0xbc,
-		0x4a, 0x16, 0x80, 0x14, 0xa3, 0xe7, 0x1c, 0x3f, 0xf1, 0x75, 0x25, 0xe8, 0xef, 0x4a, 0xee, 0x49,
-		0x48, 0x0f, 0x8c, 0x00, 0xca, 0xc1, 0x2c, 0x8f, 0x58, 0xd1, 0xad, 0x7d, 0xe6, 0xe1, 0xc4, 0x95,
-		0x04, 0x8b, 0x4c, 0xd1, 0xa3, 0x0e, 0xab, 0xb1, 0x5f, 0xfe, 0xd8, 0xa2, 0x44, 0xb7, 0x7d, 0x1e,
-		0x80, 0x59, 0xdf, 0x18, 0x88, 0x28, 0xb2, 0xe4, 0x46, 0x91, 0x5d, 0xe0, 0xe7, 0x20, 0x49, 0x14,
-		0x10, 0x6e, 0x71, 0xd8, 0x7b, 0x21, 0xcd, 0x14, 0xe4, 0x20, 0xaf, 0x99, 0xc1, 0xb3, 0x2e, 0x18,
-		0x9e, 0x13, 0x16, 0x90, 0x9f, 0xed, 0x09, 0x01, 0x75, 0x59, 0xb3, 0x72, 0x35, 0x00, 0x77, 0x50,
-		0x51, 0x1e, 0xee, 0x24, 0xca, 0xc3, 0x7b, 0x14, 0x95, 0x3f, 0x38, 0xed, 0xb3, 0x18, 0xb3, 0x04,
-		0xc8, 0x3d, 0x6e, 0xca, 0x9e, 0x9d, 0xbe, 0x42, 0x21, 0x0a, 0x4f, 0x7f, 0xea, 0x0b, 0x27, 0xa5,
-		0x6f, 0x8e, 0x2e, 0xf8, 0xbd, 0xeb, 0x70, 0xc2, 0x53, 0x48, 0x04, 0xd0, 0x17, 0x88, 0x4a, 0x7b,
-		0xe4, 0x95, 0x14, 0x4e, 0x0a, 0x28, 0x1d, 0x18, 0xff, 0xcd, 0x1e, 0xac, 0x76, 0x26, 0x47, 0x9b,
-		0x26, 0xc7, 0xbb, 0x46, 0x07, 0xe5, 0xff, 0x59, 0x1c, 0xa2, 0x0a, 0x7e, 0x4f, 0x1f, 0x5b, 0x36,
-		0x5a, 0x81, 0x10, 0x6e, 0xee, 0x9a, 0xa3, 0x62, 0xa0, 0xa4, 0x83, 0xcb, 0x1c, 0xae, 0xdc, 0xdc,
-		0x35, 0xaf, 0xcc, 0x28, 0x14, 0x16, 0x9d, 0x83, 0xf0, 0x76, 0xbb, 0xcf, 0xc3, 0x57, 0x03, 0x3a,
-		0xcb, 0x8b, 0x74, 0x89, 0x00, 0x5d, 0x99, 0x51, 0x18, 0x34, 0xa9, 0x8a, 0x7e, 0x21, 0x2c, 0x78,
-		0x70, 0x55, 0x15, 0x63, 0x9b, 0x56, 0x45, 0x60, 0x51, 0x01, 0x40, 0x37, 0x74, 0x5b, 0xa5, 0xa1,
-		0x1d, 0xae, 0x35, 0xee, 0x1a, 0x8f, 0xa9, 0xdb, 0x34, 0x18, 0x74, 0x65, 0x46, 0x89, 0xeb, 0x22,
-		0x41, 0x9a, 0xfb, 0x9e, 0x3e, 0xee, 0xed, 0x73, 0x6b, 0x6d, 0x6c, 0x73, 0x9f, 0x26, 0x40, 0xa4,
-		0xb9, 0x14, 0x9a, 0x28, 0x59, 0xf6, 0x02, 0xbd, 0xbd, 0xc7, 0xbf, 0xab, 0xb2, 0x38, 0x0e, 0x93,
-		0x3e, 0x43, 0xdf, 0xd8, 0xbb, 0x32, 0xa3, 0x44, 0x9b, 0xec, 0x27, 0x7a, 0xdc, 0x31, 0xc1, 0x12,
-		0xc3, 0x56, 0x8f, 0x0f, 0x97, 0x85, 0x7d, 0x66, 0x84, 0x29, 0x86, 0xaa, 0x90, 0x6a, 0xeb, 0x96,
-		0xad, 0x5a, 0x86, 0xd6, 0xb5, 0x76, 0x4d, 0x5b, 0x3c, 0x01, 0x7d, 0xcf, 0x38, 0x0a, 0x6b, 0xba,
-		0x65, 0xd7, 0x05, 0xf0, 0x95, 0x19, 0x65, 0xb6, 0xed, 0xcd, 0x20, 0xf4, 0xcc, 0xed, 0x6d, 0xdc,
-		0x73, 0x08, 0xd2, 0x38, 0xcb, 0x01, 0xf4, 0x6a, 0x04, 0x5a, 0xe0, 0x13, 0x7a, 0xa6, 0x37, 0x03,
-		0x7d, 0x0b, 0xcc, 0xb7, 0x4d, 0xad, 0xe5, 0x90, 0x53, 0x9b, 0xbb, 0x7d, 0xe3, 0x06, 0x0d, 0xca,
-		0x24, 0x56, 0xee, 0x1f, 0xdb, 0x48, 0x53, 0x6b, 0x09, 0x12, 0x45, 0x82, 0x70, 0x65, 0x46, 0x99,
-		0x6b, 0x0f, 0x66, 0xa2, 0x77, 0xc3, 0x82, 0xd6, 0xed, 0xb6, 0xf7, 0x07, 0xa9, 0xa7, 0x29, 0xf5,
-		0xd3, 0xe3, 0xa8, 0xe7, 0x09, 0xce, 0x20, 0x79, 0xa4, 0x0d, 0xe5, 0xa2, 0x06, 0xc8, 0xdd, 0x1e,
-		0xa6, 0xb7, 0xb9, 0xba, 0xdc, 0xca, 0xa0, 0xef, 0x2b, 0x27, 0x56, 0xee, 0x1b, 0x47, 0x7b, 0x83,
-		0xc1, 0x0b, 0xa3, 0xe4, 0xca, 0x8c, 0x92, 0xee, 0xfa, 0xb3, 0x18, 0x55, 0xb3, 0x89, 0xe9, 0x63,
-		0xf4, 0x9c, 0xea, 0xdc, 0x24, 0xaa, 0x14, 0xde, 0x4f, 0xd5, 0x97, 0x85, 0xca, 0x90, 0x60, 0xae,
-		0xa8, 0x4a, 0x94, 0x21, 0x7d, 0xe4, 0x3f, 0xb1, 0x92, 0x1b, 0x3b, 0x43, 0x29, 0xe8, 0x35, 0xd3,
-		0xc6, 0x57, 0x66, 0x14, 0xc0, 0x4e, 0x0a, 0x69, 0x70, 0x84, 0x3e, 0x50, 0xbd, 0xaf, 0xfa, 0x15,
-		0x6f, 0x66, 0x9e, 0x12, 0x7c, 0x60, 0x1c, 0x41, 0xfa, 0xe1, 0xa7, 0xfd, 0x6b, 0x5e, 0x3d, 0x7c,
-		0x65, 0x46, 0x99, 0xbf, 0x39, 0x9c, 0x4d, 0x44, 0x6c, 0x5b, 0x37, 0xb4, 0xb6, 0xfe, 0x22, 0x66,
-		0x4b, 0x28, 0xfd, 0xde, 0xc3, 0x01, 0x22, 0x76, 0x89, 0x43, 0xd3, 0x85, 0x95, 0x88, 0xd8, 0xb6,
-		0x37, 0xa3, 0x10, 0xe5, 0xe7, 0x50, 0x9d, 0x87, 0x5b, 0xa3, 0x72, 0x8c, 0x3d, 0x2f, 0x7e, 0x35,
-		0x14, 0x03, 0x39, 0x91, 0xbb, 0x0f, 0x12, 0x1e, 0xc5, 0x84, 0x32, 0x10, 0xe5, 0x27, 0x75, 0xc4,
-		0x89, 0x56, 0x9e, 0xcc, 0xa5, 0x20, 0xe9, 0x55, 0x46, 0xb9, 0x0f, 0x4a, 0x0e, 0x26, 0x7d, 0x19,
-		0x24, 0xe3, 0x8f, 0x48, 0xc7, 0x5d, 0x4b, 0xe5, 0x6e, 0xb1, 0xb4, 0x89, 0x72, 0xb6, 0xfd, 0x9a,
-		0xa4, 0x99, 0x7c, 0x65, 0x45, 0x8b, 0x90, 0xe8, 0xae, 0x74, 0x1d, 0x90, 0x20, 0x05, 0x81, 0xee,
-		0x4a, 0x57, 0x00, 0xdc, 0x05, 0x49, 0xd2, 0x6f, 0xd5, 0x6b, 0x2f, 0xc5, 0x95, 0x04, 0xc9, 0xe3,
-		0x20, 0xb9, 0xdf, 0x0a, 0x80, 0x3c, 0xa8, 0xc0, 0x9c, 0x50, 0xb5, 0x74, 0xe8, 0x50, 0xf5, 0xf1,
-		0xc1, 0x20, 0xb9, 0x1b, 0x17, 0x5f, 0x03, 0xd9, 0x0d, 0xef, 0xb2, 0xa5, 0x66, 0xbc, 0xfd, 0x37,
-		0x60, 0xa8, 0x2a, 0xe9, 0xe6, 0x80, 0xe5, 0x7a, 0xc9, 0xb7, 0x59, 0x29, 0x3e, 0xa1, 0x39, 0x38,
-		0xe0, 0x8e, 0x11, 0xb3, 0xd9, 0x6d, 0x69, 0x36, 0x16, 0xf1, 0x31, 0xcf, 0xbe, 0xe5, 0xbd, 0x90,
-		0xd6, 0xba, 0x5d, 0xd5, 0xb2, 0x35, 0x1b, 0x73, 0x5b, 0x83, 0x45, 0x1e, 0x66, 0xb5, 0x6e, 0x97,
-		0x7e, 0x71, 0x8c, 0xd9, 0x1a, 0xf7, 0x40, 0x8a, 0xe8, 0x74, 0x5d, 0x6b, 0x0b, 0x53, 0x21, 0xc2,
-		0x4c, 0x12, 0x9e, 0xcb, 0xac, 0x83, 0x5c, 0xcb, 0x19, 0x71, 0xaa, 0xcf, 0x1d, 0x9f, 0x4a, 0xf2,
-		0xf8, 0x54, 0x88, 0xbf, 0xd8, 0xc2, 0xf8, 0x23, 0x1e, 0xd7, 0x19, 0xbd, 0x69, 0xb0, 0x40, 0xfd,
-		0xaf, 0x9b, 0x2c, 0x58, 0x12, 0x53, 0x58, 0x22, 0xa7, 0x40, 0xca, 0xaf, 0xfb, 0x51, 0x0a, 0x02,
-		0xf6, 0x1e, 0xaf, 0x25, 0x60, 0xef, 0x11, 0x4b, 0xd7, 0xf3, 0xa0, 0xe0, 0xf0, 0x6a, 0xc7, 0xf1,
-		0xdc, 0x58, 0x47, 0x2e, 0x0d, 0xb3, 0xbe, 0x35, 0x21, 0x77, 0x14, 0x16, 0x46, 0xa9, 0xf8, 0xdc,
-		0xae, 0x93, 0xef, 0x53, 0xd5, 0xe8, 0x1c, 0xc4, 0x1c, 0x1d, 0x3f, 0xc2, 0x3b, 0xa6, 0xd5, 0x0a,
-		0x60, 0xc5, 0x01, 0xf5, 0x85, 0xf3, 0x03, 0xbe, 0x70, 0x7e, 0xee, 0xdb, 0x21, 0x33, 0x4e, 0x7f,
-		0x0f, 0x04, 0xf9, 0x42, 0x0e, 0xc3, 0x8e, 0x42, 0x84, 0xbf, 0x9f, 0x17, 0xa0, 0x1b, 0x58, 0x3c,
-		0x45, 0x18, 0xc9, 0x74, 0x79, 0x90, 0xed, 0x6b, 0xd1, 0x44, 0x4e, 0x85, 0xe3, 0x63, 0x75, 0xf8,
-		0xf8, 0xad, 0x30, 0x46, 0x88, 0x6f, 0x85, 0x35, 0x45, 0x73, 0x2c, 0xda, 0x57, 0x71, 0x90, 0x85,
-		0xa5, 0x72, 0xaf, 0x06, 0xe1, 0xe8, 0x68, 0x4d, 0x8e, 0x96, 0x20, 0x49, 0xec, 0x56, 0xdb, 0x6f,
-		0xe2, 0x42, 0x47, 0xdb, 0x6b, 0x70, 0xfb, 0x96, 0x6f, 0x25, 0x04, 0x9c, 0xad, 0x04, 0xb4, 0x09,
-		0x73, 0x6d, 0xb3, 0xa9, 0xb5, 0x55, 0xcf, 0x56, 0x0e, 0x9f, 0x44, 0x77, 0x0f, 0x31, 0xdb, 0x1f,
-		0x32, 0x24, 0x0a, 0x87, 0xcb, 0x7f, 0x9a, 0xd2, 0x58, 0x73, 0x76, 0x7d, 0x50, 0x09, 0x12, 0x1d,
-		0xdd, 0xda, 0xc2, 0xbb, 0xda, 0x4d, 0xdd, 0xec, 0xf1, 0xd9, 0x34, 0x2c, 0x34, 0xeb, 0x2e, 0x8c,
-		0xd8, 0x61, 0xf2, 0xa0, 0x79, 0x86, 0x24, 0x3c, 0x72, 0xe3, 0x2b, 0x72, 0x68, 0x6d, 0x32, 0x6e,
-		0x0f, 0x29, 0x3a, 0x76, 0x0f, 0x69, 0xd4, 0x86, 0x4d, 0x6c, 0xf4, 0x86, 0xcd, 0xcb, 0xde, 0xa1,
-		0xf1, 0xaf, 0x7d, 0x43, 0x7b, 0x38, 0xa8, 0x0e, 0x0b, 0x1c, 0xbf, 0xe5, 0xe3, 0xfd, 0x88, 0xa3,
-		0x0e, 0x6c, 0x7e, 0x0d, 0xf2, 0x1c, 0x09, 0xf4, 0xf1, 0x6c, 0x0f, 0xde, 0x1e, 0xdb, 0xc5, 0x26,
-		0x6a, 0xc8, 0xb3, 0x89, 0xfa, 0x7f, 0xd9, 0x50, 0xbc, 0x37, 0x08, 0x73, 0x43, 0x86, 0xc4, 0xc8,
-		0xdd, 0xe1, 0x71, 0x11, 0x59, 0xd1, 0xb1, 0xe0, 0xa1, 0x3b, 0xc6, 0xc7, 0x3a, 0x34, 0x79, 0xac,
-		0xc3, 0x6f, 0xe1, 0x58, 0x47, 0x6e, 0x6f, 0xac, 0xbf, 0xa9, 0xa3, 0xf0, 0x11, 0x09, 0xb2, 0xe3,
-		0xad, 0xaf, 0x91, 0xc3, 0x71, 0xa8, 0x0d, 0x84, 0x71, 0x6b, 0xdc, 0x3d, 0x90, 0x1a, 0xb0, 0x0d,
-		0x99, 0x28, 0xcf, 0xfa, 0xbc, 0xf0, 0xdc, 0xfb, 0x82, 0xce, 0xc2, 0xe3, 0x33, 0xe0, 0x46, 0xcc,
-		0xd6, 0xa7, 0x61, 0xbe, 0x85, 0x9b, 0x7a, 0xeb, 0x76, 0x27, 0xeb, 0x1c, 0xc7, 0xfe, 0x7f, 0x73,
-		0x75, 0x58, 0x4a, 0x7e, 0x10, 0x20, 0xa6, 0x60, 0xab, 0x4b, 0xec, 0x31, 0x54, 0x80, 0x38, 0xde,
-		0x6b, 0xe2, 0xae, 0xed, 0x1e, 0xaa, 0x18, 0xe5, 0x22, 0x30, 0xe8, 0xb2, 0x80, 0x24, 0x0e, 0xb2,
-		0x83, 0x86, 0x1e, 0xe1, 0x31, 0x80, 0xf1, 0xee, 0x3c, 0x47, 0xf7, 0x06, 0x01, 0xce, 0x8b, 0x20,
-		0x40, 0x70, 0xac, 0x7f, 0xcb, 0xb0, 0x06, 0xa2, 0x00, 0x8f, 0xf0, 0x28, 0x40, 0x68, 0x42, 0x65,
-		0xbe, 0x30, 0x40, 0xd1, 0x17, 0x06, 0x88, 0x4c, 0xe8, 0xe6, 0x98, 0x38, 0xc0, 0x79, 0x11, 0x07,
-		0x88, 0x4e, 0x68, 0xf1, 0x40, 0x20, 0xe0, 0x09, 0x4f, 0x20, 0x20, 0x3e, 0x1c, 0x6d, 0xf5, 0xa1,
-		0x8e, 0x88, 0x04, 0x5c, 0x70, 0x22, 0x01, 0xc9, 0xb1, 0x51, 0x04, 0x8e, 0x3c, 0x18, 0x0a, 0xa8,
-		0x0d, 0x85, 0x02, 0x66, 0xf9, 0xe7, 0xa0, 0xc7, 0x91, 0x98, 0x10, 0x0b, 0xa8, 0x0d, 0xc5, 0x02,
-		0x52, 0x13, 0x08, 0x4e, 0x08, 0x06, 0x7c, 0xeb, 0xe8, 0x60, 0xc0, 0x78, 0x77, 0x9d, 0x37, 0x73,
-		0xba, 0x68, 0x80, 0x3a, 0x26, 0x1a, 0x20, 0x8f, 0xf5, 0x5c, 0x19, 0xf9, 0xa9, 0xc3, 0x01, 0x9b,
-		0x23, 0xc2, 0x01, 0xcc, 0x71, 0x3f, 0x35, 0x96, 0xf8, 0x14, 0xf1, 0x80, 0xcd, 0x11, 0xf1, 0x00,
-		0x34, 0x91, 0xec, 0xc4, 0x80, 0xc0, 0x25, 0x7f, 0x40, 0x60, 0x7e, 0x8c, 0xd5, 0xe9, 0xce, 0xf6,
-		0x31, 0x11, 0x81, 0xad, 0x71, 0x11, 0x81, 0x05, 0xfe, 0x99, 0x89, 0x71, 0x14, 0x0f, 0x11, 0x12,
-		0xa8, 0x0d, 0x85, 0x04, 0x8e, 0x4c, 0x90, 0xb4, 0xe9, 0x63, 0x02, 0xec, 0xc3, 0x63, 0xec, 0x93,
-		0x63, 0x20, 0x27, 0xae, 0x86, 0x62, 0x09, 0x39, 0x99, 0xbb, 0x9f, 0x58, 0x30, 0x03, 0x7a, 0x8e,
-		0xf8, 0x0a, 0xb8, 0xd7, 0x33, 0x7b, 0xe2, 0x8e, 0x05, 0x4d, 0xe4, 0x4e, 0x11, 0x1f, 0xd1, 0xd5,
-		0x69, 0x07, 0xc4, 0x0f, 0xa8, 0x4f, 0xe6, 0xd1, 0x63, 0xb9, 0x5f, 0x96, 0x5c, 0x5c, 0x1a, 0x41,
-		0xf0, 0xfa, 0x97, 0x71, 0xee, 0x5f, 0x7a, 0xa2, 0x0a, 0x01, 0x7f, 0x54, 0x61, 0x11, 0x12, 0xc4,
-		0xd7, 0x1a, 0x08, 0x18, 0x68, 0x5d, 0x27, 0x60, 0x20, 0x0e, 0x50, 0xb1, 0xd8, 0x03, 0x5f, 0x96,
-		0xd8, 0x6e, 0x62, 0xda, 0x39, 0x4c, 0xc6, 0x5c, 0x5d, 0xf4, 0x10, 0xcc, 0x7b, 0x60, 0x1d, 0x1f,
-		0x8e, 0x79, 0xcf, 0xb2, 0x03, 0x9d, 0xe7, 0xce, 0xdc, 0xbf, 0x94, 0x5c, 0x0e, 0xb9, 0x91, 0x86,
-		0x51, 0x41, 0x01, 0xe9, 0x2d, 0x0a, 0x0a, 0x04, 0x6e, 0x3b, 0x28, 0xe0, 0xf5, 0x49, 0x83, 0x7e,
-		0x9f, 0xf4, 0x7f, 0x48, 0xee, 0x98, 0x38, 0x2e, 0x7e, 0xd3, 0x6c, 0x61, 0xee, 0x25, 0xd2, 0xdf,
-		0xc4, 0x24, 0x69, 0x9b, 0xe2, 0x7b, 0x51, 0xe4, 0x27, 0x81, 0x72, 0x16, 0x9e, 0x38, 0x5f, 0x57,
-		0x1c, 0x07, 0x33, 0xec, 0xbd, 0xc7, 0xc1, 0x2f, 0x37, 0x44, 0xdc, 0xcb, 0x0d, 0xce, 0xc5, 0xe8,
-		0xa8, 0xe7, 0x62, 0x34, 0x7a, 0x1c, 0xe2, 0x34, 0xd8, 0xaf, 0x9a, 0x5d, 0xf1, 0xe9, 0xed, 0x13,
-		0xe3, 0x2f, 0x36, 0x58, 0xf4, 0xc8, 0x35, 0xbb, 0x0c, 0xe1, 0x5a, 0x1c, 0x71, 0x9f, 0xc5, 0x71,
-		0x07, 0xc4, 0x49, 0xeb, 0xd9, 0xb7, 0x27, 0x81, 0xdf, 0xaa, 0x17, 0x19, 0xb9, 0x9f, 0x0e, 0x40,
-		0x7a, 0x60, 0xa1, 0x19, 0xd9, 0xf7, 0x51, 0xdb, 0xc8, 0xd3, 0xf1, 0xe3, 0x24, 0xc0, 0x8e, 0x66,
-		0xa9, 0x2f, 0x68, 0x86, 0xcd, 0xbf, 0x17, 0x1f, 0x54, 0x3c, 0x39, 0x28, 0x0b, 0x31, 0x92, 0xea,
-		0x5b, 0xfc, 0x8b, 0xf1, 0x41, 0xc5, 0x49, 0xa3, 0x2b, 0x10, 0xc1, 0x37, 0xe9, 0xd3, 0xc0, 0xec,
-		0x73, 0x21, 0x47, 0x87, 0xdd, 0x61, 0x52, 0x5c, 0xc8, 0x90, 0xc1, 0xfe, 0xf2, 0x6b, 0x8b, 0x32,
-		0x83, 0x7e, 0xd0, 0xb9, 0xcc, 0xa6, 0x70, 0x7c, 0x3f, 0x17, 0x62, 0x03, 0x5c, 0xa0, 0x71, 0xc0,
-		0xa4, 0x70, 0xef, 0x09, 0x4f, 0xd9, 0x19, 0x6f, 0x65, 0xb6, 0x83, 0x3b, 0x5d, 0xd3, 0x6c, 0xab,
-		0x6c, 0x8e, 0xe7, 0x21, 0xe5, 0x5f, 0x57, 0xd9, 0xe7, 0x9d, 0x6d, 0x4d, 0x37, 0x54, 0x9f, 0x11,
-		0x9c, 0x64, 0x99, 0x6c, 0x4e, 0x79, 0xdf, 0x7d, 0xce, 0x6d, 0xc0, 0x91, 0x91, 0xeb, 0x2a, 0x7a,
-		0x0c, 0xe2, 0xee, 0x92, 0xcc, 0x8e, 0xe9, 0x1f, 0x10, 0x69, 0x71, 0x61, 0x73, 0xbf, 0x2a, 0xb9,
-		0x24, 0xfd, 0xb1, 0x9b, 0x32, 0x44, 0xd8, 0x99, 0x49, 0x7e, 0x3e, 0xe6, 0xa1, 0xe9, 0x56, 0xe4,
-		0x65, 0x76, 0xa0, 0x52, 0xe1, 0xc8, 0xb9, 0x77, 0x43, 0x84, 0xe5, 0xa0, 0x04, 0x44, 0x7d, 0x0f,
-		0xd1, 0xe7, 0x8b, 0xc5, 0xf2, 0x86, 0x78, 0xda, 0xb7, 0x40, 0x1f, 0x79, 0x27, 0xd9, 0x4a, 0xf9,
-		0x6a, 0xb9, 0xd8, 0x90, 0x83, 0x68, 0x0e, 0x66, 0xd9, 0x6f, 0xfe, 0x5c, 0xbc, 0x1c, 0xf2, 0x64,
-		0xd5, 0xcb, 0xd5, 0x52, 0x59, 0x91, 0xc3, 0xb9, 0xb3, 0x70, 0x7c, 0xec, 0x1a, 0xee, 0x06, 0x66,
-		0x24, 0x4f, 0x60, 0x26, 0xf7, 0x6a, 0x80, 0x38, 0x35, 0xe3, 0x16, 0x66, 0x74, 0x75, 0xa0, 0xe3,
-		0x2b, 0x87, 0x58, 0xd5, 0x07, 0x7a, 0x4f, 0xfc, 0x98, 0x1e, 0xde, 0xc6, 0x76, 0x73, 0x97, 0x19,
-		0x0a, 0x4c, 0x03, 0xcd, 0x2a, 0xb3, 0x3c, 0x97, 0x22, 0x59, 0x0c, 0xec, 0x79, 0xdc, 0xb4, 0x55,
-		0x26, 0x44, 0x16, 0x75, 0x26, 0xe2, 0x04, 0x8c, 0xe4, 0xd6, 0x59, 0x66, 0xee, 0xdb, 0x0f, 0xc5,
-		0xcb, 0x38, 0x84, 0x95, 0x72, 0x43, 0xb9, 0xce, 0x3e, 0xe2, 0x4e, 0x7f, 0xaa, 0xf5, 0x6a, 0x7e,
-		0xa3, 0x7e, 0xa5, 0x46, 0x78, 0x39, 0x0f, 0x69, 0xc1, 0x4b, 0x91, 0x19, 0xce, 0x3d, 0x00, 0xc7,
-		0xc6, 0x58, 0x15, 0x23, 0x0e, 0xb1, 0x7e, 0x5c, 0xf2, 0x42, 0xfb, 0x2d, 0x83, 0x1a, 0x44, 0x2c,
-		0x5b, 0xb3, 0xfb, 0x16, 0x67, 0xe2, 0x63, 0xd3, 0x9a, 0x19, 0xcb, 0xe2, 0x47, 0x9d, 0xa2, 0x2b,
-		0x9c, 0x4c, 0xee, 0x1c, 0xa4, 0xfc, 0x25, 0xe3, 0x79, 0xe0, 0x0a, 0x51, 0x20, 0x77, 0x11, 0xd0,
-		0xb0, 0xf5, 0x31, 0xc2, 0xbd, 0x94, 0x46, 0xb9, 0x97, 0x3f, 0x21, 0xc1, 0x89, 0x03, 0x2c, 0x0d,
-		0xf4, 0xf4, 0x40, 0x27, 0x2f, 0x1c, 0xc6, 0x4e, 0x59, 0x66, 0x79, 0x03, 0xdd, 0x7c, 0x04, 0x92,
-		0xde, 0xfc, 0xe9, 0x3a, 0xf9, 0xe5, 0x80, 0x3b, 0x89, 0xfd, 0x7e, 0xb0, 0xab, 0x02, 0xa5, 0x6f,
-		0x50, 0x05, 0xbe, 0x13, 0xc0, 0xde, 0x13, 0xa7, 0xa8, 0xf9, 0x3a, 0x7a, 0xe7, 0x88, 0xf8, 0x22,
-		0x6e, 0x36, 0xf6, 0xf8, 0x24, 0x88, 0xdb, 0xfc, 0x97, 0x85, 0xea, 0xde, 0xa0, 0x40, 0x9f, 0xae,
-		0xb1, 0x16, 0x77, 0x98, 0xa7, 0x5d, 0x8c, 0xdd, 0xe0, 0x01, 0xcb, 0xb6, 0xd0, 0x75, 0x38, 0x36,
-		0x60, 0x28, 0x38, 0xa4, 0x43, 0xd3, 0xda, 0x0b, 0x47, 0xfc, 0xf6, 0x82, 0x20, 0xed, 0x5d, 0xed,
-		0xc3, 0xfe, 0xd5, 0xfe, 0x3a, 0x80, 0x1b, 0x1c, 0x70, 0x8f, 0xfd, 0x49, 0xde, 0x63, 0x7f, 0xe7,
-		0x20, 0x4c, 0x24, 0x49, 0xf0, 0x69, 0x58, 0x15, 0x13, 0x49, 0xf0, 0x04, 0x17, 0x18, 0x74, 0x4e,
-		0x07, 0x34, 0x1c, 0xa0, 0x1d, 0x53, 0xc5, 0x13, 0xfe, 0x2a, 0xee, 0x1a, 0x1b, 0xea, 0x1d, 0x5d,
-		0xd5, 0x8b, 0x10, 0xa6, 0x23, 0x3f, 0xf2, 0x2e, 0xe5, 0xb7, 0x01, 0x68, 0xb6, 0xdd, 0xd3, 0xb7,
-		0xfa, 0x6e, 0x05, 0x8b, 0xa3, 0x25, 0x27, 0x2f, 0xe0, 0x0a, 0x77, 0x70, 0x11, 0x5a, 0x70, 0x51,
-		0x3d, 0x62, 0xe4, 0x21, 0x98, 0xab, 0x42, 0xca, 0x8f, 0x3b, 0xfa, 0x6e, 0xe8, 0xf0, 0x87, 0x42,
-		0x5d, 0xeb, 0x88, 0x3f, 0xc6, 0x44, 0x13, 0xb9, 0x97, 0x02, 0x90, 0xf4, 0x0a, 0xde, 0xdf, 0x3e,
-		0x13, 0x24, 0xf7, 0xdd, 0x12, 0xc4, 0x9c, 0xee, 0x1f, 0x70, 0xd8, 0xd9, 0xbd, 0x23, 0xec, 0x6c,
-		0x5e, 0xb0, 0x6d, 0xa2, 0xa0, 0xb3, 0x4d, 0x74, 0xd1, 0x59, 0xfe, 0xc6, 0x05, 0x44, 0xbc, 0xbc,
-		0x16, 0x07, 0x0e, 0xf9, 0x6a, 0x7f, 0x71, 0xba, 0xab, 0x78, 0x0b, 0x10, 0xf6, 0x5e, 0xa3, 0x63,
-		0x89, 0x5c, 0xcb, 0x73, 0xc2, 0x88, 0x4d, 0x44, 0xef, 0x9d, 0x3d, 0xe9, 0xd0, 0x77, 0xf6, 0x9c,
-		0x5a, 0x02, 0xde, 0x5a, 0x3e, 0x24, 0x41, 0x4c, 0xcc, 0x09, 0xf4, 0x2e, 0xef, 0xc9, 0x33, 0xb1,
-		0xb5, 0x39, 0x56, 0x1f, 0x71, 0xfa, 0x9e, 0x83, 0x67, 0x43, 0x07, 0xae, 0x83, 0x87, 0x3d, 0x70,
-		0xcd, 0x2d, 0xbb, 0xbf, 0x90, 0x40, 0x1e, 0x9c, 0xb1, 0xdf, 0x70, 0xeb, 0x86, 0x97, 0xb9, 0xe0,
-		0x88, 0x65, 0x6e, 0xdc, 0x29, 0xea, 0xd0, 0xb8, 0x53, 0xd4, 0xc3, 0xbd, 0x0e, 0xdf, 0x66, 0xaf,
-		0xdf, 0x1b, 0x80, 0x84, 0x27, 0x3c, 0x8a, 0x1e, 0xf5, 0x9d, 0xc8, 0x5e, 0x3a, 0x28, 0x94, 0xea,
-		0x39, 0x92, 0xed, 0x63, 0x53, 0xe0, 0xf0, 0x6c, 0x7a, 0xeb, 0x6f, 0x67, 0x8d, 0xbe, 0xc0, 0x1a,
-		0x1e, 0x73, 0x81, 0xf5, 0xbb, 0x24, 0x88, 0x39, 0x66, 0xf7, 0x61, 0x37, 0x31, 0x8f, 0x42, 0x84,
-		0x5b, 0x96, 0x6c, 0x17, 0x93, 0xa7, 0x46, 0x86, 0x95, 0xb3, 0x10, 0xeb, 0x60, 0x5b, 0xa3, 0x7a,
-		0x90, 0xad, 0x6a, 0x4e, 0xfa, 0xf4, 0x05, 0x48, 0x78, 0x36, 0x80, 0x89, 0x6a, 0xac, 0x96, 0x9f,
-		0x91, 0x67, 0xb2, 0xd1, 0x57, 0x6e, 0x2d, 0x05, 0xab, 0xf8, 0x05, 0x32, 0x9b, 0x95, 0x72, 0xf1,
-		0x4a, 0xb9, 0xf8, 0x94, 0x2c, 0x65, 0x13, 0xaf, 0xdc, 0x5a, 0x8a, 0x2a, 0x98, 0x46, 0x14, 0x4f,
-		0x3f, 0x05, 0xe9, 0x81, 0x81, 0xf1, 0x9b, 0x2d, 0x08, 0x52, 0xa5, 0xcd, 0x8d, 0xb5, 0x4a, 0x31,
-		0xdf, 0x28, 0xab, 0xec, 0xdc, 0x2e, 0x3a, 0x06, 0xf3, 0x6b, 0x95, 0xcb, 0x57, 0x1a, 0x6a, 0x71,
-		0xad, 0x52, 0xae, 0x36, 0xd4, 0x7c, 0xa3, 0x91, 0x2f, 0x3e, 0x25, 0x07, 0x56, 0x6e, 0x25, 0x20,
-		0x94, 0x2f, 0x14, 0x2b, 0xa8, 0x08, 0x21, 0x1a, 0x0a, 0x39, 0xf0, 0x04, 0x58, 0xf6, 0xe0, 0xd8,
-		0x30, 0xba, 0x04, 0x61, 0x1a, 0x25, 0x41, 0x07, 0x1f, 0x09, 0xcb, 0x4e, 0x08, 0x16, 0x93, 0xc6,
-		0xd0, 0x19, 0x79, 0xe0, 0x19, 0xb1, 0xec, 0xc1, 0xb1, 0x63, 0xb4, 0x06, 0x51, 0xe1, 0x24, 0x4f,
-		0x3a, 0xb8, 0x95, 0x9d, 0x18, 0xd0, 0x25, 0x5d, 0x63, 0xc1, 0x86, 0x83, 0x8f, 0x8f, 0x65, 0x27,
-		0x44, 0x95, 0x51, 0xc5, 0xb9, 0xcf, 0x34, 0xe1, 0x44, 0x58, 0x76, 0x52, 0x9c, 0x18, 0x29, 0x10,
-		0x77, 0xc3, 0x38, 0x93, 0x0f, 0xc5, 0x65, 0xa7, 0x08, 0x98, 0xa3, 0x77, 0xc3, 0xac, 0xdf, 0xd5,
-		0x9d, 0xee, 0xd4, 0x59, 0x76, 0xca, 0x88, 0x34, 0xa1, 0xef, 0xf7, 0x7b, 0xa7, 0x3b, 0x85, 0x96,
-		0x9d, 0x32, 0x40, 0x8d, 0x9e, 0x87, 0xb9, 0x61, 0xbf, 0x74, 0xfa, 0x43, 0x69, 0xd9, 0x43, 0x84,
-		0xac, 0x51, 0x07, 0xd0, 0x08, 0x7f, 0xf6, 0x10, 0x67, 0xd4, 0xb2, 0x87, 0x89, 0x60, 0xa3, 0x16,
-		0xa4, 0x07, 0x9d, 0xc4, 0x69, 0xcf, 0xac, 0x65, 0xa7, 0x8e, 0x66, 0xb3, 0x5a, 0xfc, 0xce, 0xe5,
-		0xb4, 0x67, 0xd8, 0xb2, 0x53, 0x07, 0xb7, 0xd1, 0x26, 0x80, 0xc7, 0x3f, 0x9c, 0xe2, 0x4c, 0x5b,
-		0x76, 0x9a, 0x30, 0x37, 0xea, 0xc2, 0xfc, 0x28, 0xc7, 0xf1, 0x30, 0x47, 0xdc, 0xb2, 0x87, 0x8a,
-		0x7e, 0x13, 0x79, 0xf6, 0xbb, 0x80, 0xd3, 0x1d, 0x79, 0xcb, 0x4e, 0x19, 0x06, 0x2f, 0xe4, 0xc7,
-		0x9e, 0x73, 0xbe, 0xef, 0xc0, 0x73, 0xce, 0xee, 0xc9, 0x65, 0xe7, 0x6c, 0xf3, 0xbf, 0x3f, 0x03,
-		0xef, 0xe0, 0x2f, 0xe8, 0x58, 0xb6, 0x76, 0x43, 0x37, 0x76, 0x9c, 0x67, 0x96, 0x78, 0x9a, 0x1f,
-		0x72, 0x3e, 0xca, 0x5f, 0xe9, 0x11, 0xb9, 0x13, 0x1e, 0x5b, 0x1a, 0xfb, 0x02, 0xe5, 0xa4, 0xfb,
-		0x10, 0x93, 0x8f, 0x2f, 0x1f, 0xf0, 0x90, 0xd3, 0x84, 0xe7, 0xa2, 0x46, 0x3c, 0xf4, 0x94, 0x3d,
-		0xf0, 0x8d, 0x81, 0xec, 0x41, 0xe7, 0xbe, 0x89, 0x15, 0x9b, 0xba, 0xa2, 0x5b, 0xb6, 0xd9, 0xd3,
-		0x9b, 0x5a, 0x9b, 0x2e, 0x2f, 0x17, 0xa7, 0xbd, 0x95, 0x55, 0x88, 0x13, 0x73, 0x85, 0xbf, 0x05,
-		0xc5, 0x6f, 0x0a, 0x95, 0x20, 0x72, 0x53, 0x6b, 0xb3, 0x3b, 0x51, 0xde, 0x87, 0xe0, 0x06, 0x79,
-		0xee, 0xb1, 0xa3, 0xbc, 0x54, 0x18, 0x6e, 0xee, 0x87, 0xe8, 0x7d, 0x92, 0x4e, 0x47, 0xb7, 0x88,
-		0x2c, 0x2a, 0xd4, 0x95, 0xbe, 0x0a, 0xa1, 0x9e, 0x66, 0x73, 0x07, 0xb3, 0x70, 0xfe, 0xd0, 0xef,
-		0x32, 0xb1, 0x1a, 0x28, 0x0d, 0xf4, 0x34, 0xc4, 0x3a, 0xda, 0x9e, 0x4a, 0xe9, 0x05, 0xbe, 0x21,
-		0x7a, 0xd1, 0x8e, 0xb6, 0x47, 0xda, 0x87, 0xde, 0x4d, 0x3f, 0x3f, 0xa8, 0x36, 0x77, 0x35, 0x63,
-		0x07, 0x33, 0xca, 0xc1, 0x6f, 0x88, 0xf2, 0x6c, 0x47, 0xdb, 0x2b, 0x52, 0x6a, 0x84, 0x3e, 0x7f,
-		0xf2, 0xea, 0xd7, 0x25, 0x1e, 0x35, 0xa0, 0x8c, 0x41, 0x1a, 0xc8, 0x4d, 0x27, 0x45, 0x2b, 0x15,
-		0x5b, 0x1c, 0xf7, 0x8d, 0xe3, 0xfb, 0x00, 0x5b, 0x0b, 0xb3, 0xa4, 0x79, 0x9f, 0x7f, 0x6d, 0x51,
-		0x62, 0xb5, 0xa6, 0x9b, 0x43, 0x6c, 0x4f, 0xb0, 0x60, 0x88, 0x4a, 0x6d, 0xd8, 0xc0, 0x44, 0x1b,
-		0x76, 0x56, 0xd8, 0xb0, 0x8c, 0x20, 0x30, 0x6c, 0x52, 0xce, 0xfb, 0xf0, 0x29, 0x09, 0x12, 0x25,
-		0xcf, 0xb3, 0x8e, 0x19, 0x88, 0x76, 0x4c, 0x43, 0xbf, 0x81, 0x7b, 0xce, 0x1e, 0x15, 0x4b, 0x12,
-		0x3b, 0x93, 0x7d, 0x8c, 0xda, 0xde, 0x17, 0xaf, 0x0b, 0x89, 0x34, 0xc1, 0x7a, 0x01, 0x6f, 0x59,
-		0xba, 0xe0, 0xb3, 0x22, 0x92, 0xe8, 0x7e, 0x90, 0x2d, 0xdc, 0xec, 0xf7, 0x74, 0x7b, 0x5f, 0x6d,
-		0x9a, 0x86, 0xad, 0x35, 0x6d, 0xee, 0x87, 0xa7, 0x45, 0x7e, 0x91, 0x65, 0x13, 0x22, 0x2d, 0x6c,
-		0x6b, 0x7a, 0x9b, 0x9d, 0xcc, 0x8c, 0x2b, 0x22, 0xc9, 0x9b, 0xfa, 0x4a, 0xd4, 0xeb, 0x87, 0x16,
-		0x41, 0x36, 0xbb, 0xb8, 0xe7, 0x3b, 0x90, 0xc2, 0xa4, 0x31, 0xf3, 0x3b, 0x9f, 0x7d, 0x68, 0x81,
-		0x33, 0x9c, 0x1f, 0x66, 0x60, 0x5f, 0x31, 0x50, 0xd2, 0x02, 0x43, 0x9c, 0x54, 0xb9, 0xee, 0xdb,
-		0x95, 0xea, 0x6f, 0xb9, 0xcf, 0xc8, 0x2c, 0x0c, 0x31, 0x35, 0x6f, 0xec, 0x17, 0x32, 0x9f, 0x73,
-		0x49, 0xbb, 0x7e, 0xea, 0x53, 0x78, 0xdf, 0xbb, 0x45, 0x45, 0xc9, 0x10, 0x13, 0xfe, 0x79, 0x4d,
-		0x6f, 0xe3, 0x16, 0x0f, 0x6b, 0xf0, 0x14, 0x5a, 0x75, 0xc2, 0x8b, 0xec, 0x9b, 0x9a, 0xb9, 0x71,
-		0xb2, 0x51, 0x30, 0x8d, 0x96, 0x3f, 0x8e, 0x88, 0x8a, 0x10, 0xb1, 0xcd, 0x1b, 0xd8, 0xe0, 0x0c,
-		0x3a, 0xdc, 0xd3, 0x6a, 0x1c, 0x15, 0x7d, 0x2b, 0xc8, 0x2d, 0xdc, 0xc6, 0x3b, 0xec, 0xbe, 0xe4,
-		0xae, 0xd6, 0xc3, 0xec, 0xb6, 0xfe, 0x6d, 0x3d, 0xaf, 0x96, 0x76, 0x48, 0xd5, 0x29, 0x25, 0xb4,
-		0xe1, 0x7f, 0x38, 0x34, 0xca, 0x37, 0x8f, 0xc7, 0xf4, 0xd1, 0x23, 0x79, 0x5e, 0xcd, 0xe3, 0x7b,
-		0x68, 0xf4, 0x7e, 0x90, 0xfb, 0xc6, 0x96, 0x69, 0xd0, 0x0f, 0x44, 0x72, 0x2f, 0x2a, 0xc6, 0x76,
-		0x2a, 0x9d, 0x7c, 0xbe, 0x53, 0xb9, 0x01, 0x29, 0x17, 0x94, 0xce, 0x90, 0xf8, 0x61, 0x67, 0xc8,
-		0xac, 0x43, 0x80, 0x80, 0xa0, 0x75, 0x00, 0x77, 0x0e, 0xd2, 0xad, 0xb2, 0xc4, 0xf8, 0x11, 0x73,
-		0x67, 0xb3, 0xb7, 0x33, 0x1e, 0x02, 0xe8, 0x5b, 0x60, 0xbe, 0xa3, 0x1b, 0xaa, 0x85, 0xdb, 0xdb,
-		0x2a, 0xe7, 0x1c, 0xa1, 0x9b, 0x38, 0xfc, 0x68, 0xce, 0x75, 0x74, 0xa3, 0x8e, 0xdb, 0xdb, 0x25,
-		0x87, 0x0a, 0x7a, 0x27, 0x9c, 0x70, 0x7b, 0x6f, 0x1a, 0xea, 0xae, 0xd9, 0x6e, 0xa9, 0x3d, 0xbc,
-		0xad, 0x36, 0xe9, 0x3b, 0x7f, 0x49, 0xca, 0xb3, 0x63, 0x0e, 0x48, 0xcd, 0xb8, 0x62, 0xb6, 0x5b,
-		0x0a, 0xde, 0x2e, 0x92, 0x62, 0x74, 0x37, 0xb8, 0x5d, 0x57, 0xf5, 0x96, 0x95, 0x99, 0x5d, 0x0a,
-		0x9e, 0x0a, 0x29, 0x49, 0x27, 0xb3, 0xd2, 0xb2, 0x56, 0x63, 0x2f, 0x7f, 0x6c, 0x71, 0xe6, 0x8d,
-		0x8f, 0x2d, 0xce, 0xe4, 0x2e, 0xd1, 0x37, 0xa5, 0xf8, 0x3c, 0xc2, 0x16, 0x3a, 0x0f, 0x71, 0x4d,
-		0x24, 0xd8, 0x8d, 0xb1, 0x03, 0xe6, 0xa1, 0x0b, 0x9a, 0xfb, 0x29, 0x09, 0x22, 0xa5, 0x6b, 0x1b,
-		0x9a, 0xde, 0x43, 0x65, 0x98, 0x73, 0x05, 0x73, 0xda, 0x29, 0xed, 0xca, 0xb2, 0x98, 0xd3, 0xd5,
-		0x71, 0x47, 0xd5, 0xe2, 0x85, 0xbb, 0x7e, 0xe7, 0xb3, 0x0f, 0xdd, 0xc9, 0xc9, 0x5c, 0x1b, 0x38,
-		0xb5, 0x26, 0xe8, 0x0d, 0x9e, 0x66, 0xf3, 0xf4, 0xf9, 0x2a, 0x44, 0x59, 0x53, 0x2d, 0xf4, 0x24,
-		0x84, 0xbb, 0xe4, 0x07, 0x8f, 0xc0, 0x9f, 0x1c, 0x2b, 0xe0, 0x14, 0xde, 0x2b, 0x0e, 0x0c, 0x2f,
-		0xf7, 0xfe, 0x00, 0x40, 0xe9, 0xda, 0xb5, 0x46, 0x4f, 0xef, 0xb6, 0xb1, 0xfd, 0x56, 0xf5, 0x7d,
-		0x13, 0x8e, 0x78, 0xee, 0x42, 0xf7, 0x9a, 0x87, 0xef, 0xff, 0xbc, 0x7b, 0x2d, 0xba, 0xd7, 0x1c,
-		0x49, 0xb6, 0x65, 0xd9, 0x0e, 0xd9, 0xe0, 0xe1, 0xc9, 0x96, 0x2c, 0x7b, 0x98, 0xb3, 0xcf, 0x42,
-		0xc2, 0x65, 0x86, 0x85, 0x2a, 0x10, 0xb3, 0xf9, 0x6f, 0xce, 0xe0, 0xdc, 0x78, 0x06, 0x0b, 0x34,
-		0x2f, 0x93, 0x1d, 0xf4, 0xdc, 0x5f, 0x49, 0x00, 0x9e, 0x39, 0xf2, 0xf6, 0x94, 0x31, 0xe2, 0xae,
-		0x73, 0x4d, 0x1c, 0xbc, 0xed, 0xd7, 0x38, 0x19, 0x01, 0x0f, 0x53, 0x3f, 0x10, 0x80, 0xf9, 0x4d,
-		0x31, 0x7b, 0xdf, 0xfe, 0x3c, 0xd8, 0x84, 0x28, 0x36, 0xec, 0x9e, 0xee, 0xec, 0x21, 0x3d, 0x3c,
-		0x6e, 0xcc, 0x47, 0x74, 0xaa, 0x6c, 0xd8, 0xbd, 0x7d, 0xaf, 0x04, 0x08, 0x5a, 0x1e, 0x7e, 0x7c,
-		0x38, 0x08, 0x99, 0x71, 0xa8, 0xe8, 0x3e, 0x48, 0x37, 0x7b, 0x98, 0x66, 0xf8, 0xaf, 0x88, 0xa6,
-		0x44, 0x36, 0x5f, 0x63, 0x14, 0x20, 0x56, 0x19, 0x11, 0x2e, 0x02, 0x7a, 0x7b, 0x66, 0x58, 0xca,
-		0xa5, 0x40, 0x57, 0x99, 0x06, 0xa4, 0xc5, 0x9d, 0x93, 0x2d, 0xad, 0xad, 0x19, 0x4d, 0x61, 0xae,
-		0x1e, 0x6a, 0x49, 0x10, 0xf7, 0x56, 0x0a, 0x8c, 0x04, 0x2a, 0x43, 0x54, 0x50, 0x0b, 0x1d, 0x9e,
-		0x9a, 0xc0, 0x45, 0x77, 0x41, 0xd2, 0xbb, 0x30, 0x50, 0xd3, 0x23, 0xa4, 0x24, 0x3c, 0xeb, 0xc2,
-		0xa4, 0x95, 0x27, 0x72, 0xe0, 0xca, 0xc3, 0xad, 0xbb, 0x1f, 0xa3, 0x47, 0xc3, 0x5b, 0x7f, 0xf3,
-		0x87, 0x65, 0x03, 0x80, 0x4d, 0x55, 0xa2, 0x49, 0xf9, 0xc8, 0xdc, 0xc6, 0x7c, 0x8f, 0x33, 0x22,
-		0x25, 0xcb, 0xfe, 0xeb, 0x1a, 0xa1, 0xdf, 0x0f, 0x40, 0xd2, 0x3b, 0x42, 0x7f, 0x2b, 0x17, 0x2d,
-		0x54, 0x75, 0xd5, 0x14, 0xbb, 0x3e, 0x73, 0xff, 0x38, 0x35, 0x35, 0x24, 0xcd, 0x13, 0xf4, 0xd3,
-		0x47, 0x82, 0x10, 0xe1, 0xe7, 0xdb, 0x6a, 0x43, 0x86, 0xac, 0x34, 0xe9, 0x01, 0x80, 0x59, 0xf1,
-		0x00, 0xc0, 0x48, 0x3b, 0xf6, 0x1e, 0x48, 0x11, 0x87, 0xd8, 0x77, 0x68, 0x4e, 0x3a, 0x35, 0x4b,
-		0xfd, 0x5a, 0xf7, 0x88, 0x38, 0x5a, 0x84, 0x04, 0x01, 0x73, 0xf5, 0x30, 0x81, 0x81, 0x8e, 0xb6,
-		0x57, 0x66, 0x39, 0xe8, 0x21, 0x40, 0xbb, 0x4e, 0x80, 0x42, 0x75, 0x19, 0x41, 0xe0, 0xe6, 0xdc,
-		0x12, 0x01, 0x7e, 0x27, 0x00, 0x69, 0x85, 0xca, 0x1e, 0xa0, 0xe6, 0xcf, 0x7b, 0x93, 0x9c, 0x12,
-		0x7d, 0x84, 0xfa, 0x7d, 0x12, 0xb3, 0x87, 0x07, 0xdc, 0x66, 0xee, 0x8e, 0x34, 0xa6, 0x98, 0x14,
-		0x7f, 0xfe, 0xda, 0x62, 0x76, 0x5f, 0xeb, 0xb4, 0x57, 0x73, 0x23, 0xe8, 0xe4, 0x46, 0x79, 0xf2,
-		0xc4, 0x70, 0xf6, 0xbb, 0xdd, 0xab, 0xef, 0x20, 0xe2, 0xfd, 0xca, 0xeb, 0x9f, 0x3e, 0x7d, 0xc2,
-		0xf3, 0xe6, 0xf3, 0x9e, 0x13, 0xbe, 0x62, 0x63, 0x42, 0x2c, 0x55, 0xe4, 0xae, 0x1a, 0xce, 0xc9,
-		0xf8, 0x75, 0x00, 0x8f, 0x25, 0x2f, 0x1d, 0xec, 0x21, 0xb8, 0xf8, 0x3e, 0x0f, 0xc1, 0x33, 0xa7,
-		0xde, 0xe5, 0x2a, 0x6d, 0xf1, 0xe6, 0xc3, 0x88, 0x17, 0xc9, 0x97, 0x8b, 0xa6, 0xee, 0x23, 0x21,
-		0x90, 0xe8, 0x54, 0x9d, 0xc9, 0xfd, 0x5b, 0x09, 0x8e, 0x0f, 0x89, 0x9f, 0xd3, 0xe4, 0x26, 0xa0,
-		0x9e, 0xa7, 0x90, 0x0e, 0xa3, 0xd8, 0x8a, 0xbd, 0x3d, 0x69, 0x9e, 0xeb, 0x0d, 0x69, 0xee, 0xb7,
-		0x66, 0xf5, 0xe1, 0xaa, 0xe7, 0x37, 0x25, 0x58, 0xf0, 0x36, 0xc0, 0xe9, 0x4a, 0x1d, 0x92, 0xde,
-		0xaa, 0x79, 0x27, 0xde, 0x31, 0x4d, 0x27, 0xbc, 0xed, 0xf7, 0x11, 0x41, 0xd7, 0xdc, 0x29, 0xce,
-		0xe2, 0x66, 0x67, 0xa7, 0x66, 0x8a, 0x68, 0xd8, 0xc8, 0xa9, 0xce, 0xc6, 0xe6, 0x2b, 0x12, 0x84,
-		0x36, 0x4c, 0xb3, 0x8d, 0xde, 0x03, 0x73, 0x86, 0x69, 0xab, 0x64, 0x3a, 0xe0, 0x96, 0xca, 0x1d,
-		0x7b, 0xa6, 0x3e, 0xcb, 0x07, 0xf2, 0xea, 0xcb, 0xaf, 0x2d, 0x0e, 0x63, 0x8e, 0x7a, 0x13, 0x3e,
-		0x6d, 0x98, 0x76, 0x81, 0x02, 0x35, 0x98, 0xef, 0xbf, 0x0d, 0xb3, 0xfe, 0xea, 0x98, 0x8a, 0xcd,
-		0x4f, 0xaa, 0x6e, 0x76, 0x62, 0x55, 0xc9, 0x2d, 0x4f, 0x3d, 0xec, 0x19, 0xe5, 0x3f, 0x25, 0x23,
-		0x77, 0x1d, 0xe4, 0x6b, 0x83, 0x47, 0x7c, 0xca, 0x10, 0x15, 0x47, 0x7a, 0xa4, 0x29, 0x4f, 0x0b,
-		0x79, 0xd9, 0xc9, 0x71, 0x4f, 0xff, 0xa2, 0x04, 0xe0, 0x06, 0x49, 0xd0, 0x83, 0x70, 0xac, 0x50,
-		0xab, 0x96, 0xd4, 0x7a, 0x23, 0xdf, 0xd8, 0xac, 0xfb, 0xbf, 0x24, 0x22, 0xde, 0x1f, 0xb2, 0xba,
-		0xb8, 0xa9, 0x6f, 0xeb, 0xb8, 0x85, 0xee, 0x85, 0x05, 0x3f, 0x34, 0x49, 0x95, 0x4b, 0xb2, 0x94,
-		0x4d, 0xbe, 0x72, 0x6b, 0x29, 0xc6, 0xec, 0x44, 0xdc, 0x42, 0xa7, 0xe0, 0xc8, 0x30, 0x5c, 0xa5,
-		0x7a, 0x59, 0x0e, 0x64, 0x67, 0x5f, 0xb9, 0xb5, 0x14, 0x77, 0x0c, 0x4a, 0x94, 0x03, 0xe4, 0x85,
-		0xe4, 0xf4, 0x82, 0x59, 0x78, 0xe5, 0xd6, 0x52, 0x84, 0x8d, 0x42, 0x36, 0xf4, 0xf2, 0x8f, 0x9f,
-		0x9c, 0x39, 0xfd, 0x6d, 0x00, 0x15, 0x63, 0xbb, 0xa7, 0xd1, 0xcf, 0xe9, 0xa3, 0x2c, 0x1c, 0xad,
-		0x54, 0x2f, 0x29, 0xf9, 0x22, 0xfd, 0xcc, 0xbf, 0xff, 0x03, 0x28, 0xfe, 0xb2, 0x52, 0x6d, 0xb3,
-		0xb0, 0x56, 0x56, 0xeb, 0x95, 0xcb, 0x55, 0xb6, 0xd9, 0xea, 0x2b, 0x7b, 0xa6, 0xda, 0xa8, 0xac,
-		0x97, 0xe5, 0x40, 0xe1, 0xd2, 0xd8, 0x60, 0xfe, 0x83, 0x07, 0xbe, 0x72, 0xef, 0x6a, 0x3c, 0x5f,
-		0x44, 0xff, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x14, 0xa8, 0x34, 0x02, 0x86, 0xb2, 0x00, 0x00,
+		0xb3, 0x85, 0x2b, 0xc6, 0xb6, 0xa9, 0xa4, 0x2c, 0xdf, 0x37, 0x3a, 0x0a, 0x11, 0x6b, 0xdf, 0xb0,
+		0xb5, 0xbd, 0x4c, 0x92, 0x6a, 0x08, 0xff, 0x42, 0x2b, 0x10, 0xc5, 0x2d, 0x9d, 0x34, 0x97, 0x49,
+		0x2d, 0x49, 0xa7, 0x52, 0x2b, 0x99, 0x61, 0x19, 0xb3, 0x7a, 0x45, 0x00, 0xe6, 0x7e, 0x25, 0x02,
+		0xe9, 0x69, 0xd4, 0xf2, 0x22, 0x84, 0xb7, 0x89, 0x64, 0x32, 0x81, 0xc3, 0xc8, 0x8d, 0xe1, 0xf8,
+		0x05, 0x1f, 0xb9, 0x4d, 0xc1, 0xe7, 0x21, 0x61, 0x60, 0xcb, 0xc6, 0x2d, 0xa6, 0x45, 0xc1, 0x29,
+		0xf5, 0x10, 0x18, 0xd2, 0xb0, 0x1a, 0x86, 0x6e, 0x4b, 0x0d, 0x9f, 0x85, 0xb4, 0xc3, 0x92, 0xda,
+		0xd3, 0x8c, 0x1d, 0xa1, 0xcf, 0x67, 0x26, 0x71, 0xb2, 0xec, 0xd8, 0x03, 0x85, 0xa0, 0x29, 0x29,
+		0xec, 0xfb, 0x46, 0x25, 0x00, 0xd3, 0xc0, 0xe6, 0xb6, 0xda, 0xc2, 0xcd, 0x76, 0x26, 0x36, 0x46,
+		0x4a, 0x35, 0x02, 0x32, 0x24, 0x25, 0x93, 0x95, 0x36, 0xdb, 0xe8, 0x82, 0xab, 0x9e, 0xd1, 0x31,
+		0xda, 0xb5, 0xce, 0x26, 0xe6, 0x90, 0x86, 0x6e, 0x42, 0xaa, 0x87, 0xc9, 0x5c, 0xc1, 0x2d, 0xde,
+		0xb3, 0x38, 0x65, 0x62, 0x79, 0x62, 0xcf, 0x14, 0x8e, 0xc6, 0x3a, 0x36, 0xdb, 0xf3, 0x7e, 0xa2,
+		0xbb, 0xc1, 0x29, 0x50, 0xa9, 0x5a, 0x01, 0xb5, 0x5c, 0x49, 0x51, 0x58, 0xd5, 0x3a, 0x38, 0xfb,
+		0x22, 0xa4, 0xfc, 0xe2, 0x41, 0x0b, 0x10, 0xb6, 0x6c, 0xad, 0x67, 0x53, 0x2d, 0x0c, 0x2b, 0xec,
+		0x03, 0xc9, 0x10, 0xc4, 0x46, 0x8b, 0x5a, 0xc6, 0xb0, 0x42, 0xfe, 0x44, 0xff, 0x9f, 0xdb, 0xe1,
+		0x20, 0xed, 0xf0, 0xbd, 0xc3, 0x23, 0xea, 0xa3, 0x3c, 0xd8, 0xef, 0xec, 0x63, 0x30, 0xeb, 0xeb,
+		0xc0, 0xb4, 0x4d, 0xe7, 0x7e, 0x2b, 0x04, 0x47, 0x46, 0xd2, 0x46, 0xcf, 0xc2, 0x42, 0xdf, 0xd0,
+		0x0d, 0x1b, 0xf7, 0xba, 0x3d, 0x4c, 0x54, 0x96, 0xb5, 0x95, 0x79, 0x3d, 0x3a, 0x46, 0xe9, 0x36,
+		0xbd, 0xd0, 0x8c, 0x8a, 0x32, 0xdf, 0x1f, 0x2e, 0x44, 0xd7, 0x21, 0x41, 0xf4, 0x43, 0xeb, 0x69,
+		0x94, 0x20, 0x9b, 0x8d, 0x2b, 0xd3, 0x75, 0x79, 0xb9, 0xe4, 0x62, 0x16, 0x82, 0x2f, 0x4b, 0x01,
+		0xc5, 0x4b, 0x0b, 0x3d, 0x06, 0xb1, 0x6d, 0xac, 0xd9, 0xfd, 0x1e, 0xb6, 0x32, 0x2b, 0x54, 0x94,
+		0x27, 0x86, 0x27, 0x29, 0x03, 0xa8, 0x63, 0x5b, 0x71, 0x80, 0x51, 0x07, 0x92, 0x37, 0x71, 0x4f,
+		0xdf, 0xd6, 0x9b, 0x8c, 0xa9, 0x20, 0x35, 0x3e, 0x8f, 0x4f, 0xc9, 0xd4, 0x35, 0x0f, 0x6a, 0xdd,
+		0xd6, 0x6c, 0xbc, 0x0a, 0x9b, 0xd5, 0x6b, 0x65, 0xa5, 0x72, 0xa9, 0x52, 0x2e, 0x31, 0x36, 0x7d,
+		0xe4, 0xb3, 0x3f, 0x28, 0x41, 0xc2, 0xd3, 0x13, 0x62, 0x0e, 0x8d, 0x7e, 0x67, 0x0b, 0xf7, 0xf8,
+		0x78, 0xf1, 0x2f, 0x74, 0x02, 0xe2, 0xdb, 0xfd, 0x76, 0x9b, 0x29, 0x1d, 0x5b, 0x4b, 0x63, 0xa4,
+		0x80, 0x28, 0x1c, 0xb1, 0x71, 0xdc, 0x8c, 0x50, 0x1b, 0x47, 0xfe, 0x46, 0x59, 0x88, 0x09, 0xa5,
+		0xcc, 0x84, 0x97, 0xa4, 0x53, 0x31, 0xc5, 0xf9, 0x66, 0x75, 0x5d, 0xac, 0xd9, 0xb8, 0x95, 0x89,
+		0x88, 0x3a, 0xf6, 0x7d, 0x35, 0x14, 0x0b, 0xc9, 0xe1, 0xdc, 0xa3, 0x30, 0x37, 0xd4, 0x15, 0x94,
+		0x86, 0x44, 0xa9, 0x5c, 0x5c, 0xcb, 0x2b, 0xf9, 0x46, 0xa5, 0x56, 0x95, 0x67, 0x50, 0x0a, 0x3c,
+		0xbd, 0x93, 0xa5, 0xd3, 0xf1, 0xd8, 0x1b, 0x51, 0xf9, 0xa5, 0x97, 0x5e, 0x7a, 0x29, 0x90, 0xfb,
+		0xf5, 0x08, 0x2c, 0x8c, 0x32, 0x82, 0x23, 0xed, 0xb1, 0xdb, 0xe9, 0xa0, 0xaf, 0xd3, 0x79, 0x08,
+		0xb7, 0xb5, 0x2d, 0xdc, 0xce, 0x84, 0xe8, 0x20, 0x3c, 0x30, 0x95, 0x99, 0x5d, 0x5e, 0x23, 0x28,
+		0x0a, 0xc3, 0x44, 0xef, 0xe2, 0xa2, 0x09, 0x53, 0x0a, 0xa7, 0xa7, 0xa3, 0x40, 0x8c, 0x23, 0x17,
+		0xe3, 0x09, 0x88, 0x93, 0xff, 0x99, 0xdc, 0x23, 0x4c, 0xee, 0xa4, 0x80, 0xca, 0x3d, 0x0b, 0x31,
+		0x6a, 0xf7, 0x5a, 0xd8, 0x19, 0x13, 0xf1, 0x4d, 0x2c, 0x45, 0x0b, 0x6f, 0x6b, 0xfd, 0xb6, 0xad,
+		0xde, 0xd4, 0xda, 0x7d, 0x4c, 0x2d, 0x58, 0x5c, 0x49, 0xf2, 0xc2, 0x6b, 0xa4, 0x0c, 0x2d, 0x42,
+		0x82, 0x99, 0x49, 0xdd, 0x68, 0xe1, 0x3d, 0xba, 0x84, 0x86, 0x15, 0x66, 0x39, 0x2b, 0xa4, 0x84,
+		0x34, 0xff, 0xbc, 0x65, 0x1a, 0xc2, 0xd6, 0xd0, 0x26, 0x48, 0x01, 0x6d, 0xfe, 0xb1, 0xc1, 0xd5,
+		0xfb, 0xce, 0xd1, 0xdd, 0x1b, 0x32, 0x8e, 0xf7, 0x41, 0x9a, 0x42, 0x3c, 0xc2, 0xa7, 0xb2, 0xd6,
+		0xce, 0xcc, 0x51, 0x35, 0x48, 0xb1, 0xe2, 0x1a, 0x2f, 0xcd, 0xfd, 0x62, 0x00, 0x42, 0x74, 0xa5,
+		0x48, 0x43, 0xa2, 0x71, 0x7d, 0xa3, 0xac, 0x96, 0x6a, 0x9b, 0x85, 0xb5, 0xb2, 0x2c, 0x91, 0xa1,
+		0xa7, 0x05, 0x97, 0xd6, 0x6a, 0xf9, 0x86, 0x1c, 0x70, 0xbe, 0x2b, 0xd5, 0xc6, 0xf9, 0x47, 0xe5,
+		0xa0, 0x83, 0xb0, 0xc9, 0x0a, 0x42, 0x5e, 0x80, 0x47, 0x56, 0xe4, 0x30, 0x92, 0x21, 0xc9, 0x08,
+		0x54, 0x9e, 0x2d, 0x97, 0xce, 0x3f, 0x2a, 0x47, 0xfc, 0x25, 0x8f, 0xac, 0xc8, 0x51, 0x34, 0x0b,
+		0x71, 0x5a, 0x52, 0xa8, 0xd5, 0xd6, 0xe4, 0x98, 0x43, 0xb3, 0xde, 0x50, 0x2a, 0xd5, 0xcb, 0x72,
+		0xdc, 0xa1, 0x79, 0x59, 0xa9, 0x6d, 0x6e, 0xc8, 0xe0, 0x50, 0x58, 0x2f, 0xd7, 0xeb, 0xf9, 0xcb,
+		0x65, 0x39, 0xe1, 0x40, 0x14, 0xae, 0x37, 0xca, 0x75, 0x39, 0xe9, 0x63, 0xeb, 0x91, 0x15, 0x79,
+		0xd6, 0x69, 0xa2, 0x5c, 0xdd, 0x5c, 0x97, 0x53, 0x68, 0x0e, 0x66, 0x59, 0x13, 0x82, 0x89, 0xf4,
+		0x40, 0xd1, 0xf9, 0x47, 0x65, 0xd9, 0x65, 0x84, 0x51, 0x99, 0xf3, 0x15, 0x9c, 0x7f, 0x54, 0x46,
+		0xb9, 0x22, 0x84, 0xa9, 0x1a, 0x22, 0x04, 0xa9, 0xb5, 0x7c, 0xa1, 0xbc, 0xa6, 0xd6, 0x36, 0xc8,
+		0xa4, 0xc9, 0xaf, 0xc9, 0x92, 0x5b, 0xa6, 0x94, 0x37, 0xca, 0xf9, 0x46, 0xb9, 0x24, 0x07, 0xbd,
+		0x65, 0x4f, 0x6f, 0x56, 0x94, 0x72, 0x49, 0x0e, 0xe4, 0x9a, 0xb0, 0x30, 0x6a, 0x85, 0x1c, 0x39,
+		0x85, 0x3c, 0xba, 0x10, 0x18, 0xa3, 0x0b, 0x94, 0xd6, 0xa0, 0x2e, 0xe4, 0xbe, 0x18, 0x80, 0xf9,
+		0x11, 0x5e, 0xc2, 0xc8, 0x46, 0x9e, 0x84, 0x30, 0xd3, 0x65, 0x66, 0xa9, 0xef, 0x1f, 0xe9, 0x6e,
+		0x50, 0xcd, 0x1e, 0xf2, 0x9d, 0x28, 0x9e, 0xd7, 0xdf, 0x0c, 0x8e, 0xf1, 0x37, 0x09, 0x89, 0x21,
+		0x85, 0xfd, 0xb6, 0xa1, 0xd5, 0x9c, 0x39, 0x3c, 0xe7, 0xa7, 0x71, 0x78, 0x68, 0xd9, 0xe1, 0x56,
+		0xf5, 0xf0, 0x88, 0x55, 0xfd, 0x22, 0xcc, 0x0d, 0x11, 0x9a, 0x7a, 0x75, 0x7d, 0xaf, 0x04, 0x99,
+		0x71, 0xc2, 0x99, 0x60, 0x12, 0x03, 0x3e, 0x93, 0x78, 0x71, 0x50, 0x82, 0x77, 0x8d, 0x1f, 0x84,
+		0xa1, 0xb1, 0xfe, 0xa4, 0x04, 0x47, 0x47, 0xc7, 0x15, 0x23, 0x79, 0x78, 0x17, 0x44, 0x3a, 0xd8,
+		0xde, 0x35, 0x85, 0x9f, 0x7c, 0xef, 0x08, 0xef, 0x8b, 0x54, 0x0f, 0x0e, 0x36, 0xc7, 0xf2, 0xba,
+		0x6f, 0xc1, 0x71, 0xc1, 0x01, 0xe3, 0x66, 0x88, 0xd3, 0xef, 0x0d, 0xc0, 0x91, 0x91, 0xc4, 0x47,
+		0x32, 0x7a, 0x27, 0x80, 0x6e, 0x74, 0xfb, 0x36, 0xf3, 0x85, 0x99, 0x25, 0x8e, 0xd3, 0x12, 0x6a,
+		0xbc, 0x88, 0x95, 0xed, 0xdb, 0x4e, 0x3d, 0x5b, 0x25, 0x81, 0x15, 0x51, 0x80, 0xc7, 0x5d, 0x46,
+		0x43, 0x94, 0xd1, 0x93, 0x63, 0x7a, 0x3a, 0xa4, 0x98, 0x0f, 0x83, 0xdc, 0x6c, 0xeb, 0xd8, 0xb0,
+		0x55, 0xcb, 0xee, 0x61, 0xad, 0xa3, 0x1b, 0x3b, 0x6c, 0xb5, 0x5d, 0x0d, 0x6f, 0x6b, 0x6d, 0x0b,
+		0x2b, 0x69, 0x56, 0x5d, 0x17, 0xb5, 0x04, 0x83, 0x2a, 0x50, 0xcf, 0x83, 0x11, 0xf1, 0x61, 0xb0,
+		0x6a, 0x07, 0x23, 0xf7, 0x73, 0x71, 0x48, 0x78, 0xa2, 0x30, 0x74, 0x17, 0x24, 0x9f, 0xd7, 0x6e,
+		0x6a, 0xaa, 0x88, 0xac, 0x99, 0x24, 0x12, 0xa4, 0x6c, 0x83, 0x47, 0xd7, 0x0f, 0xc3, 0x02, 0x05,
+		0x31, 0xfb, 0x36, 0xee, 0xa9, 0xcd, 0xb6, 0x66, 0x59, 0x54, 0x68, 0x31, 0x0a, 0x8a, 0x48, 0x5d,
+		0x8d, 0x54, 0x15, 0x45, 0x0d, 0x3a, 0x07, 0xf3, 0x14, 0xa3, 0xd3, 0x6f, 0xdb, 0x7a, 0xb7, 0x8d,
+		0x69, 0xce, 0xc0, 0xa2, 0x4b, 0x8e, 0xc3, 0xd9, 0x1c, 0x81, 0x58, 0xe7, 0x00, 0x84, 0x23, 0x0b,
+		0x95, 0xe0, 0x4e, 0x8a, 0xb6, 0x83, 0x0d, 0xdc, 0xd3, 0x6c, 0xac, 0xe2, 0xf7, 0xf4, 0xb5, 0xb6,
+		0xa5, 0x6a, 0x46, 0x4b, 0xdd, 0xd5, 0xac, 0xdd, 0xcc, 0x02, 0x21, 0x50, 0x08, 0x64, 0x24, 0xe5,
+		0x38, 0x01, 0xbc, 0xcc, 0xe1, 0xca, 0x14, 0x2c, 0x6f, 0xb4, 0xae, 0x68, 0xd6, 0x2e, 0x5a, 0x85,
+		0xa3, 0x94, 0x8a, 0x65, 0xf7, 0x74, 0x63, 0x47, 0x6d, 0xee, 0xe2, 0xe6, 0x0d, 0xb5, 0x6f, 0x6f,
+		0x3f, 0x9e, 0x39, 0xe1, 0x6d, 0x9f, 0x72, 0x58, 0xa7, 0x30, 0x45, 0x02, 0xb2, 0x69, 0x6f, 0x3f,
+		0x8e, 0xea, 0x90, 0x24, 0x83, 0xd1, 0xd1, 0x5f, 0xc4, 0xea, 0xb6, 0xd9, 0xa3, 0x6b, 0x68, 0x6a,
+		0x84, 0x69, 0xf2, 0x48, 0x70, 0xb9, 0xc6, 0x11, 0xd6, 0xcd, 0x16, 0x5e, 0x0d, 0xd7, 0x37, 0xca,
+		0xe5, 0x92, 0x92, 0x10, 0x54, 0x2e, 0x99, 0x3d, 0xa2, 0x50, 0x3b, 0xa6, 0x23, 0xe0, 0x04, 0x53,
+		0xa8, 0x1d, 0x53, 0x88, 0xf7, 0x1c, 0xcc, 0x37, 0x9b, 0xac, 0xcf, 0x7a, 0x53, 0xe5, 0x11, 0xb9,
+		0x95, 0x91, 0x7d, 0xc2, 0x6a, 0x36, 0x2f, 0x33, 0x00, 0xae, 0xe3, 0x16, 0xba, 0x00, 0x47, 0x5c,
+		0x61, 0x79, 0x11, 0xe7, 0x86, 0x7a, 0x39, 0x88, 0x7a, 0x0e, 0xe6, 0xbb, 0xfb, 0xc3, 0x88, 0xc8,
+		0xd7, 0x62, 0x77, 0x7f, 0x10, 0xed, 0x1e, 0x9a, 0x65, 0xe9, 0xe1, 0x26, 0x75, 0xf5, 0x8e, 0x79,
+		0xa1, 0x3d, 0x15, 0x68, 0x19, 0xe4, 0x66, 0x53, 0xc5, 0x86, 0xb6, 0xd5, 0xc6, 0xaa, 0xd6, 0xc3,
+		0x86, 0x66, 0x65, 0x16, 0x29, 0x70, 0xc8, 0xee, 0xf5, 0xb1, 0x92, 0x6a, 0x36, 0xcb, 0xb4, 0x32,
+		0x4f, 0xeb, 0xd0, 0x69, 0x98, 0x33, 0xb7, 0x9e, 0x6f, 0x32, 0xc5, 0x52, 0xbb, 0x3d, 0xbc, 0xad,
+		0xef, 0x65, 0xde, 0x41, 0xa5, 0x94, 0x26, 0x15, 0x54, 0xad, 0x36, 0x68, 0x31, 0xba, 0x1f, 0xe4,
+		0xa6, 0xb5, 0xab, 0xf5, 0xba, 0xd4, 0xb2, 0x5a, 0x5d, 0xad, 0x89, 0x33, 0xf7, 0x30, 0x50, 0x56,
+		0x5e, 0x15, 0xc5, 0x44, 0xb1, 0xad, 0x17, 0xf4, 0x6d, 0x5b, 0x50, 0xbc, 0x8f, 0x29, 0x36, 0x2d,
+		0xe3, 0xd4, 0x4e, 0x81, 0xdc, 0xdd, 0xed, 0xfa, 0x1b, 0x3e, 0x45, 0xc1, 0x52, 0xdd, 0xdd, 0xae,
+		0xb7, 0xdd, 0xbb, 0x61, 0x96, 0x40, 0xba, 0x8d, 0xde, 0xcf, 0xfc, 0xaf, 0xee, 0xae, 0xa7, 0xc5,
+		0x47, 0xe1, 0x28, 0x01, 0xea, 0x60, 0x5b, 0x6b, 0x69, 0xb6, 0xe6, 0x81, 0x7e, 0x90, 0x42, 0x2f,
+		0x74, 0x77, 0xbb, 0xeb, 0xbc, 0xd2, 0xc7, 0x67, 0xaf, 0xbf, 0xb5, 0xef, 0xe8, 0xc7, 0x43, 0x8c,
+		0x4f, 0x52, 0x26, 0x34, 0xe4, 0xb6, 0xc3, 0x8f, 0x6f, 0x5a, 0xb0, 0x95, 0x5b, 0x85, 0xa4, 0x57,
+		0xef, 0x51, 0x1c, 0x98, 0xe6, 0xcb, 0x12, 0x71, 0x82, 0x8a, 0xb5, 0x12, 0x71, 0x5f, 0x9e, 0x2b,
+		0xcb, 0x01, 0xe2, 0x46, 0xad, 0x55, 0x1a, 0x65, 0x55, 0xd9, 0xac, 0x36, 0x2a, 0xeb, 0x65, 0x39,
+		0xe8, 0x71, 0xec, 0xaf, 0x86, 0x62, 0xa7, 0xe5, 0x07, 0xae, 0x86, 0x62, 0xf7, 0xca, 0xf7, 0x51,
+		0xf1, 0x0c, 0x29, 0x65, 0xee, 0xcd, 0x20, 0xa4, 0xfc, 0x61, 0x39, 0x7a, 0x27, 0x1c, 0x13, 0x79,
+		0x37, 0x0b, 0xdb, 0xea, 0x0b, 0x7a, 0x8f, 0x4e, 0xd6, 0x8e, 0xc6, 0x16, 0x4e, 0x47, 0x29, 0x17,
+		0x38, 0x54, 0x1d, 0xdb, 0xcf, 0xe8, 0x3d, 0x32, 0x15, 0x3b, 0x9a, 0x8d, 0xd6, 0x60, 0xd1, 0x30,
+		0x55, 0xcb, 0xd6, 0x8c, 0x96, 0xd6, 0x6b, 0x79, 0x13, 0x99, 0x5a, 0xb3, 0x89, 0x2d, 0xcb, 0x64,
+		0x8b, 0xa4, 0x43, 0xe5, 0x0e, 0xc3, 0xac, 0x73, 0x60, 0x77, 0xf5, 0xc8, 0x73, 0xd0, 0x81, 0x39,
+		0x11, 0x1c, 0x37, 0x27, 0x4e, 0x40, 0xbc, 0xa3, 0x75, 0x55, 0x6c, 0xd8, 0xbd, 0x7d, 0xea, 0xbb,
+		0xc7, 0x94, 0x58, 0x47, 0xeb, 0x96, 0xc9, 0x37, 0xba, 0x06, 0xf7, 0xba, 0xa0, 0x6a, 0x1b, 0xef,
+		0x68, 0xcd, 0x7d, 0x95, 0x3a, 0xea, 0x34, 0x47, 0xa4, 0x36, 0x4d, 0x63, 0xbb, 0xad, 0x37, 0x6d,
+		0x8b, 0xda, 0x0e, 0x66, 0xff, 0x72, 0x2e, 0xc6, 0x1a, 0x45, 0xb8, 0x6a, 0x99, 0x06, 0xf5, 0xcf,
+		0x8b, 0x02, 0xda, 0xa7, 0x36, 0xc9, 0xb7, 0x85, 0xda, 0xf8, 0x87, 0x3e, 0x24, 0x87, 0xaf, 0x86,
+		0x62, 0x61, 0x39, 0x72, 0x35, 0x14, 0x8b, 0xc8, 0xd1, 0xab, 0xa1, 0x58, 0x4c, 0x8e, 0x5f, 0x0d,
+		0xc5, 0xe2, 0x32, 0xe4, 0x6e, 0xcd, 0x42, 0xd2, 0x1b, 0x6e, 0x90, 0xe8, 0xad, 0x49, 0x17, 0x5c,
+		0x89, 0x9a, 0xe4, 0xbb, 0x0f, 0x0c, 0x4e, 0x96, 0x8b, 0x64, 0x25, 0x5e, 0x8d, 0x30, 0xdf, 0x5e,
+		0x61, 0x98, 0xc4, 0x0b, 0x22, 0x93, 0x0c, 0x33, 0x5f, 0x2a, 0xa6, 0xf0, 0x2f, 0x74, 0x19, 0x22,
+		0xcf, 0x5b, 0x94, 0x76, 0x84, 0xd2, 0x7e, 0xc7, 0xc1, 0xb4, 0xaf, 0xd6, 0x29, 0xf1, 0xf8, 0xd5,
+		0xba, 0x5a, 0xad, 0x29, 0xeb, 0xf9, 0x35, 0x85, 0xa3, 0xa3, 0xe3, 0x10, 0x6a, 0x6b, 0x2f, 0xee,
+		0xfb, 0xd7, 0x6c, 0x5a, 0x84, 0x96, 0x21, 0xdd, 0x37, 0x58, 0xac, 0x4e, 0xc6, 0x98, 0x40, 0xa5,
+		0xbd, 0x50, 0x29, 0xb7, 0x76, 0x8d, 0xc0, 0x4f, 0xa9, 0x57, 0xc7, 0x21, 0xf4, 0x02, 0xd6, 0x6e,
+		0xf8, 0x57, 0x56, 0x5a, 0x84, 0x4e, 0x41, 0xb2, 0x85, 0xb7, 0xfa, 0x3b, 0x6a, 0x0f, 0xb7, 0xb4,
+		0xa6, 0xed, 0x5f, 0x4f, 0x12, 0xb4, 0x4a, 0xa1, 0x35, 0xe8, 0x29, 0x88, 0x93, 0x31, 0x32, 0xe8,
+		0x18, 0xcf, 0x51, 0x11, 0x3c, 0x74, 0xb0, 0x08, 0xf8, 0x10, 0x0b, 0x24, 0xc5, 0xc5, 0x47, 0x57,
+		0x20, 0x6a, 0x6b, 0xbd, 0x1d, 0x6c, 0x5b, 0x99, 0xf9, 0xa5, 0xe0, 0xa9, 0xd4, 0x88, 0x1c, 0xd9,
+		0x08, 0x52, 0x0d, 0x8a, 0x42, 0x23, 0x65, 0x81, 0x8e, 0x9e, 0x01, 0x99, 0xa7, 0x62, 0x55, 0x1e,
+		0xe6, 0x5a, 0x99, 0x05, 0xaa, 0x80, 0x0f, 0x1e, 0x4c, 0x92, 0x67, 0x72, 0x4b, 0x0c, 0x49, 0x49,
+		0x63, 0xdf, 0xb7, 0x7f, 0x5e, 0x1c, 0x39, 0xcc, 0xbc, 0xd8, 0x84, 0x34, 0xff, 0x5b, 0xb5, 0xfa,
+		0xdd, 0xae, 0xd9, 0xb3, 0x33, 0x47, 0x29, 0xfe, 0x04, 0x86, 0x04, 0x31, 0x86, 0xa3, 0xa4, 0xb6,
+		0x7d, 0xdf, 0xdf, 0xbc, 0xe9, 0x96, 0x7d, 0x0e, 0x52, 0x7e, 0x61, 0x78, 0x13, 0xe1, 0xc1, 0x29,
+		0x13, 0xe1, 0x24, 0x2c, 0x11, 0x81, 0x1a, 0x59, 0x9a, 0xd8, 0x47, 0xf6, 0x87, 0x02, 0x90, 0xf2,
+		0x77, 0x0c, 0x5d, 0x06, 0x24, 0x46, 0x4c, 0x37, 0xec, 0x9e, 0xd9, 0xea, 0x37, 0x71, 0x8b, 0x4f,
+		0xd8, 0xf1, 0xed, 0xcc, 0x71, 0x9c, 0x8a, 0x83, 0xe2, 0x25, 0xe4, 0x99, 0x05, 0x81, 0x29, 0x09,
+		0x95, 0xdc, 0xf9, 0x71, 0x06, 0xe6, 0x05, 0x01, 0x42, 0xec, 0x05, 0xad, 0x67, 0x10, 0x17, 0x99,
+		0x39, 0xed, 0xc8, 0x53, 0xf5, 0x0c, 0xab, 0x41, 0x79, 0x10, 0xea, 0xa2, 0xf6, 0x70, 0xc7, 0xbc,
+		0x89, 0x5b, 0x3c, 0x5d, 0x34, 0xbe, 0xd9, 0x14, 0x47, 0x50, 0x18, 0x7c, 0xee, 0x0c, 0x84, 0xa9,
+		0xf9, 0x41, 0x00, 0xdc, 0x00, 0xc9, 0x33, 0x28, 0x06, 0xa1, 0x62, 0x4d, 0x21, 0xcb, 0xa3, 0x0c,
+		0x49, 0x56, 0xaa, 0x6e, 0x54, 0xca, 0xc5, 0xb2, 0x1c, 0xc8, 0x9d, 0x83, 0x08, 0xb3, 0x29, 0x64,
+		0xe9, 0x74, 0xac, 0x8a, 0x3c, 0xc3, 0x3f, 0x39, 0x0d, 0x49, 0xd4, 0x6e, 0xae, 0x17, 0xca, 0x8a,
+		0x1c, 0xc8, 0x6d, 0x42, 0x7a, 0x60, 0x1e, 0xa2, 0x23, 0x30, 0xa7, 0x94, 0x1b, 0xe5, 0x6a, 0xa3,
+		0x52, 0xab, 0xaa, 0x9b, 0xd5, 0xa7, 0xaa, 0xb5, 0x67, 0xaa, 0xf2, 0x8c, 0xbf, 0x58, 0xac, 0xc3,
+		0x12, 0x5a, 0x00, 0xd9, 0x2d, 0xae, 0xd7, 0x36, 0x15, 0xca, 0xcd, 0xf7, 0x05, 0x40, 0x1e, 0x9c,
+		0x94, 0xe8, 0x18, 0xcc, 0x37, 0xf2, 0xca, 0xe5, 0x72, 0x43, 0x65, 0x09, 0x0f, 0x87, 0xf4, 0x02,
+		0xc8, 0xde, 0x8a, 0x4b, 0x15, 0x9a, 0xcf, 0x59, 0x84, 0x13, 0xde, 0xd2, 0xf2, 0xb3, 0x8d, 0x72,
+		0xb5, 0x4e, 0x1b, 0xcf, 0x57, 0x2f, 0x13, 0xa7, 0x60, 0x80, 0x9e, 0x48, 0xb1, 0x04, 0x09, 0xab,
+		0x7e, 0x7a, 0xe5, 0xb5, 0x92, 0x1c, 0x1a, 0x2c, 0xae, 0x55, 0xcb, 0xb5, 0x4b, 0x72, 0x78, 0xb0,
+		0x75, 0x9a, 0x76, 0x89, 0xa0, 0x2c, 0x1c, 0x1d, 0x2c, 0x55, 0xcb, 0xd5, 0x86, 0x72, 0x5d, 0x8e,
+		0x0e, 0x36, 0x5c, 0x2f, 0x2b, 0xd7, 0x2a, 0xc5, 0xb2, 0x1c, 0x43, 0x47, 0x01, 0xf9, 0x39, 0x6a,
+		0x5c, 0xa9, 0x95, 0xe4, 0xf8, 0xa8, 0x15, 0x0b, 0xc9, 0xf3, 0xb9, 0x9f, 0x95, 0x20, 0xe9, 0x4d,
+		0x81, 0xf8, 0x8c, 0x8a, 0xf4, 0x76, 0x5b, 0x6c, 0x73, 0xbf, 0x1d, 0x80, 0x84, 0x27, 0x17, 0x42,
+		0x82, 0x58, 0xad, 0xdd, 0x36, 0x5f, 0x50, 0xb5, 0xb6, 0xae, 0x59, 0x7c, 0x3d, 0x04, 0x5a, 0x94,
+		0x27, 0x25, 0xd3, 0xae, 0x3f, 0xd3, 0xbb, 0x2e, 0x91, 0xdb, 0x76, 0x5d, 0xa2, 0x6f, 0x43, 0xd7,
+		0x25, 0x2c, 0x47, 0x72, 0xbf, 0x17, 0x00, 0x79, 0x30, 0x3b, 0x32, 0x20, 0x37, 0x69, 0x9c, 0xdc,
+		0xbc, 0xfd, 0x0b, 0x1c, 0xa6, 0x7f, 0x83, 0xab, 0x7a, 0x70, 0xec, 0xaa, 0x3e, 0x62, 0xb1, 0x0a,
+		0xbd, 0x9d, 0x17, 0x2b, 0xaf, 0xba, 0xfe, 0x47, 0x09, 0x52, 0xfe, 0x64, 0x8e, 0x4f, 0x62, 0xb9,
+		0xc3, 0x48, 0xcc, 0x3f, 0x22, 0x77, 0x8d, 0x1b, 0x91, 0xbf, 0x91, 0x7e, 0xfd, 0x48, 0x10, 0x66,
+		0x7d, 0xb9, 0x9f, 0x69, 0xb9, 0x7b, 0x0f, 0xcc, 0xe9, 0x2d, 0xdc, 0xe9, 0x9a, 0x36, 0x36, 0x9a,
+		0xfb, 0x6a, 0x1b, 0xdf, 0xc4, 0x6d, 0x2a, 0x86, 0xd4, 0x88, 0xdd, 0x55, 0x5f, 0x0b, 0xcb, 0x15,
+		0x17, 0x6f, 0x8d, 0xa0, 0xad, 0xce, 0x57, 0x4a, 0xe5, 0xf5, 0x8d, 0x5a, 0xa3, 0x5c, 0x2d, 0x5e,
+		0x17, 0x96, 0x5c, 0x91, 0xf5, 0x01, 0x30, 0x9f, 0xc0, 0xef, 0x7e, 0x7b, 0x04, 0x9d, 0x1b, 0x20,
+		0x0f, 0xf6, 0x86, 0x18, 0xf4, 0x11, 0xfd, 0x91, 0x67, 0xd0, 0x3c, 0xa4, 0xab, 0x35, 0xb5, 0x5e,
+		0x29, 0x95, 0xd5, 0xf2, 0xa5, 0x4b, 0xe5, 0x62, 0xa3, 0xce, 0x36, 0x1a, 0x1c, 0xe8, 0x86, 0x1c,
+		0xf0, 0x8e, 0xcd, 0x8f, 0x06, 0x61, 0x7e, 0x04, 0x27, 0x28, 0xcf, 0x53, 0x84, 0x2c, 0x6b, 0xf9,
+		0xd0, 0x34, 0xdc, 0x2f, 0x93, 0xe8, 0x7e, 0x43, 0xeb, 0xd9, 0x3c, 0xa3, 0x78, 0x3f, 0x10, 0xf1,
+		0x1a, 0x36, 0x71, 0xef, 0x7b, 0x7c, 0x03, 0x87, 0xb9, 0x20, 0x69, 0xb7, 0x9c, 0xed, 0xe1, 0x3c,
+		0x08, 0xa8, 0x6b, 0x5a, 0xba, 0xad, 0xdf, 0xc4, 0xc4, 0x87, 0xe2, 0xc0, 0x64, 0xe2, 0x86, 0x14,
+		0x59, 0xd4, 0x54, 0x0c, 0xdb, 0x81, 0x36, 0xf0, 0x8e, 0x36, 0x00, 0x4d, 0xc2, 0x8f, 0xa0, 0x22,
+		0x8b, 0x1a, 0x07, 0xfa, 0x2e, 0x48, 0xb6, 0xcc, 0xfe, 0x56, 0x1b, 0x73, 0x38, 0x62, 0x92, 0x25,
+		0x25, 0xc1, 0xca, 0x1c, 0x10, 0x9e, 0x36, 0x73, 0xb7, 0x99, 0x92, 0x4a, 0x82, 0x95, 0x31, 0x90,
+		0xfb, 0x20, 0xad, 0xed, 0xec, 0xf4, 0x08, 0x71, 0x41, 0x88, 0x25, 0x02, 0x53, 0x4e, 0x31, 0x05,
+		0xcc, 0x5e, 0x85, 0x98, 0x90, 0x03, 0x89, 0x7f, 0x89, 0x24, 0xd4, 0x2e, 0xcb, 0x6e, 0x07, 0x4e,
+		0xc5, 0x95, 0x98, 0x21, 0x2a, 0xef, 0x82, 0xa4, 0x6e, 0xb9, 0x47, 0x88, 0x32, 0x81, 0xa5, 0xc0,
+		0xa9, 0x98, 0x92, 0xd0, 0x2d, 0xf7, 0x98, 0xd0, 0xef, 0xcf, 0x02, 0xb8, 0xca, 0x86, 0x7e, 0x40,
+		0x82, 0x14, 0x5b, 0x60, 0xba, 0x3d, 0x6c, 0x61, 0xa3, 0x29, 0xc2, 0xc2, 0xfb, 0x0f, 0x50, 0x51,
+		0x66, 0xe6, 0x36, 0x38, 0x42, 0xe1, 0xc9, 0x97, 0x25, 0xe9, 0x55, 0x29, 0xf4, 0xaa, 0x24, 0x7d,
+		0x5c, 0x9a, 0x45, 0xb1, 0xf2, 0xb3, 0x1b, 0x6b, 0x95, 0x62, 0xa5, 0x91, 0x79, 0x5f, 0x94, 0x7e,
+		0x57, 0xd6, 0xf9, 0xf7, 0xeb, 0x51, 0x7f, 0xfd, 0x1b, 0xd1, 0xcf, 0x48, 0xc1, 0xd8, 0x1b, 0x51,
+		0x65, 0x76, 0xdb, 0x4b, 0x0f, 0xb5, 0xbd, 0x27, 0x28, 0x02, 0xe3, 0x02, 0x49, 0x97, 0x9b, 0x32,
+		0x3f, 0x37, 0x51, 0xb8, 0x9f, 0x32, 0x12, 0xa1, 0x8c, 0x24, 0x50, 0xa4, 0xb8, 0x56, 0xab, 0x97,
+		0x4b, 0x94, 0x8d, 0x38, 0x0a, 0xd5, 0x36, 0xca, 0xd5, 0xcc, 0xeb, 0xa2, 0x49, 0xf7, 0xb0, 0xc5,
+		0xab, 0x12, 0x1c, 0x13, 0xbb, 0xac, 0x7c, 0xad, 0xc5, 0x46, 0xd3, 0x6c, 0x09, 0xef, 0x36, 0xb5,
+		0x72, 0xf6, 0xa0, 0xc6, 0x15, 0x8e, 0x4a, 0x45, 0x52, 0xe6, 0x88, 0x85, 0x87, 0x86, 0x44, 0x92,
+		0xaf, 0x96, 0x38, 0x2f, 0x09, 0x14, 0xd9, 0xc8, 0x17, 0x9f, 0x2a, 0x97, 0x5c, 0x6e, 0x8e, 0xf4,
+		0x46, 0x51, 0x41, 0xdf, 0x01, 0xe9, 0xbe, 0xbd, 0xfd, 0x38, 0xd1, 0x0d, 0xbd, 0xc5, 0xb6, 0xbd,
+		0x43, 0xe3, 0xf6, 0x4b, 0x5d, 0x8e, 0x36, 0xed, 0xed, 0xc7, 0xaf, 0x39, 0x18, 0x5c, 0x28, 0x8c,
+		0x95, 0x38, 0x0a, 0x55, 0x6b, 0xd5, 0xb2, 0x60, 0x83, 0x6e, 0x11, 0x5f, 0x77, 0xd9, 0x48, 0xf5,
+		0x7d, 0xa8, 0xe8, 0x3b, 0x40, 0x16, 0xe9, 0x21, 0x47, 0x24, 0xe1, 0x71, 0x5b, 0xbe, 0x2e, 0x03,
+		0x3c, 0xc9, 0xe4, 0x08, 0xe3, 0x5e, 0x0f, 0x07, 0x0b, 0x28, 0xbd, 0x56, 0xae, 0x5e, 0x6e, 0x5c,
+		0x51, 0x37, 0x94, 0x32, 0xdd, 0xb9, 0xcb, 0xbc, 0x4f, 0x34, 0x9f, 0xee, 0xf8, 0x11, 0xd1, 0x77,
+		0x49, 0x90, 0x60, 0x2e, 0x10, 0xcb, 0x49, 0xb1, 0xa4, 0xc2, 0xbd, 0x07, 0xb5, 0x4d, 0x3d, 0x20,
+		0x0a, 0x5d, 0xb8, 0x40, 0x9b, 0x0d, 0x0a, 0x85, 0x38, 0x86, 0xd0, 0x5a, 0xf9, 0x72, 0xbe, 0x78,
+		0x5d, 0x2d, 0x94, 0xeb, 0x0d, 0x62, 0xc9, 0x6a, 0x0a, 0xd3, 0x51, 0x40, 0xe1, 0xfc, 0xda, 0x5a,
+		0xed, 0x19, 0x57, 0x10, 0xf0, 0xbc, 0x43, 0x06, 0xfd, 0x8c, 0x04, 0x0b, 0xd8, 0xd8, 0x36, 0x7b,
+		0x4d, 0xba, 0xdb, 0x4c, 0x66, 0xb4, 0x65, 0xef, 0xb7, 0xd9, 0x8c, 0x1e, 0x19, 0x94, 0x7b, 0x35,
+		0x93, 0xe2, 0x55, 0x29, 0x5a, 0x9d, 0x60, 0x15, 0x2a, 0x2f, 0x4b, 0x81, 0x57, 0x09, 0x63, 0x01,
+		0xca, 0x5b, 0xe8, 0x55, 0x29, 0x4c, 0x39, 0x8c, 0xbe, 0x2a, 0xc5, 0x5e, 0x95, 0xe2, 0x1f, 0x97,
+		0xe6, 0x50, 0xb2, 0xde, 0xb8, 0xbe, 0x56, 0x56, 0x19, 0xb7, 0x94, 0xc3, 0x14, 0x8a, 0xd3, 0xb2,
+		0x95, 0x87, 0x57, 0x1e, 0xcd, 0x7c, 0x89, 0x72, 0xf9, 0xa5, 0xa8, 0x82, 0xf0, 0x10, 0xf9, 0xdc,
+		0xb7, 0xc2, 0xac, 0x6f, 0x72, 0x12, 0x17, 0x9e, 0xba, 0xfe, 0x44, 0xde, 0xf5, 0x72, 0xb5, 0xe8,
+		0x0d, 0x39, 0x92, 0xe0, 0x4c, 0x46, 0x59, 0x22, 0x5f, 0x62, 0xaa, 0xca, 0x01, 0x62, 0xf4, 0xb9,
+		0xb8, 0x9c, 0x9d, 0xcf, 0x60, 0xee, 0x31, 0x88, 0x89, 0xc9, 0x46, 0x02, 0x09, 0x1a, 0x0f, 0x0c,
+		0x84, 0x31, 0x31, 0xa0, 0x33, 0x4d, 0x96, 0x48, 0xd0, 0xc6, 0x66, 0xa0, 0x1c, 0xc8, 0x5d, 0x83,
+		0x23, 0x23, 0x27, 0x0a, 0xba, 0x1b, 0x16, 0xc5, 0x6e, 0x2b, 0x0b, 0x51, 0xd4, 0x72, 0xb5, 0x58,
+		0x2b, 0x91, 0xa0, 0xce, 0xa5, 0x09, 0xc0, 0x67, 0x0c, 0xe3, 0x52, 0xcc, 0x26, 0x39, 0x90, 0xab,
+		0x40, 0xca, 0xaf, 0xee, 0xe8, 0x04, 0x1c, 0xdb, 0x6c, 0x5c, 0x7a, 0x5c, 0xbd, 0x96, 0x5f, 0xab,
+		0x94, 0xf2, 0x03, 0xe1, 0x1b, 0x00, 0xd7, 0x79, 0x39, 0x40, 0x18, 0x25, 0x73, 0x41, 0x0e, 0xe6,
+		0x42, 0x31, 0x49, 0x96, 0x72, 0x75, 0x48, 0x0f, 0x28, 0x2e, 0xba, 0x03, 0x32, 0x3c, 0x9e, 0x1a,
+		0xc5, 0x15, 0x95, 0x90, 0x4f, 0x95, 0x59, 0x64, 0x59, 0x2a, 0xaf, 0x55, 0xd6, 0x2b, 0x0d, 0xca,
+		0xdf, 0x15, 0x00, 0x57, 0x23, 0xc9, 0x0a, 0x7b, 0xb5, 0x5e, 0xab, 0xaa, 0x97, 0x48, 0x58, 0xda,
+		0xf0, 0x90, 0x8a, 0x03, 0xd3, 0x40, 0x59, 0x22, 0xd1, 0xd3, 0xb0, 0x9a, 0xca, 0x81, 0xdc, 0x33,
+		0x80, 0x86, 0xb5, 0x09, 0x2d, 0xc1, 0x1d, 0xe5, 0xea, 0xa5, 0x9a, 0x52, 0x2c, 0xab, 0xd5, 0xfc,
+		0x3a, 0xe1, 0x8f, 0xe9, 0x8e, 0x4b, 0x7a, 0x16, 0x5c, 0xd5, 0x11, 0x31, 0xb3, 0xab, 0x5d, 0x72,
+		0xe0, 0xf4, 0xa7, 0x25, 0xb2, 0x72, 0xbf, 0xbf, 0x9a, 0xfd, 0xa4, 0x84, 0xee, 0x8c, 0xbd, 0x11,
+		0x45, 0xd1, 0xe5, 0xee, 0xd6, 0x72, 0xb3, 0xdb, 0xcd, 0xa6, 0xc9, 0x1f, 0xc5, 0x6e, 0xf7, 0x92,
+		0xf0, 0x47, 0x16, 0x63, 0x5f, 0x8a, 0xa2, 0x18, 0x29, 0x7d, 0x5e, 0xbb, 0xa9, 0x65, 0x65, 0xf2,
+		0xd7, 0x55, 0xed, 0xa6, 0xe6, 0x00, 0x9c, 0x88, 0x7d, 0x39, 0x8a, 0x22, 0xa4, 0x78, 0xc7, 0xcc,
+		0xa6, 0xc8, 0xff, 0x97, 0x4d, 0xa7, 0xf2, 0xee, 0xd8, 0x57, 0xa2, 0x08, 0x48, 0x61, 0x77, 0xdf,
+		0xde, 0x35, 0x8d, 0x2c, 0x22, 0x7f, 0x6f, 0xd0, 0xbf, 0x3d, 0x40, 0xdf, 0x53, 0xe5, 0x40, 0x64,
+		0x3e, 0x9d, 0xe5, 0x40, 0xf4, 0x6f, 0x01, 0x74, 0x3a, 0x12, 0x7b, 0x7f, 0x55, 0xfe, 0x60, 0xf5,
+		0x74, 0x24, 0xf6, 0xc1, 0xaa, 0xfc, 0x03, 0xd5, 0xab, 0x91, 0xd8, 0xeb, 0x51, 0xf9, 0x8d, 0x68,
+		0xee, 0x4f, 0x83, 0x80, 0xdc, 0xd9, 0xe7, 0x64, 0xa9, 0x9e, 0x85, 0x98, 0x93, 0xf6, 0x62, 0x87,
+		0x7a, 0xdf, 0x79, 0xc0, 0xa4, 0x15, 0x68, 0x9e, 0xa2, 0x81, 0x34, 0x98, 0x43, 0x0d, 0xe5, 0x21,
+		0xdd, 0xd1, 0x0d, 0xbd, 0xd3, 0xef, 0xa8, 0x22, 0x17, 0x34, 0x31, 0xc7, 0xc1, 0x11, 0xf8, 0x37,
+		0x25, 0xa1, 0xed, 0xf9, 0x48, 0x84, 0x27, 0x92, 0x60, 0x08, 0xfc, 0x3b, 0xfb, 0xd7, 0x12, 0x64,
+		0xc6, 0x31, 0x7b, 0x5b, 0x69, 0xaa, 0x2a, 0x2c, 0x98, 0x37, 0x71, 0xaf, 0xa7, 0xb7, 0xe8, 0xce,
+		0x93, 0xe3, 0xbc, 0x86, 0x26, 0x3b, 0xaf, 0xf3, 0x1e, 0x44, 0x67, 0x50, 0x0b, 0xc4, 0xc7, 0xd8,
+		0x23, 0xcb, 0xab, 0xa0, 0x14, 0x9e, 0x4c, 0x69, 0x96, 0xa2, 0x08, 0x1a, 0x57, 0xc9, 0x24, 0x25,
+		0xf1, 0x62, 0x40, 0x0e, 0xba, 0x1e, 0x72, 0xee, 0x23, 0x41, 0x48, 0xf9, 0x0f, 0xb2, 0xa2, 0x12,
+		0xc4, 0xda, 0x26, 0x3f, 0x24, 0xc6, 0x46, 0xfb, 0xd4, 0x84, 0xb3, 0xaf, 0xcb, 0x6b, 0x1c, 0x5e,
+		0x71, 0x30, 0xb3, 0xff, 0x41, 0x82, 0x98, 0x28, 0x46, 0x47, 0x21, 0xd4, 0xd5, 0xec, 0x5d, 0x4a,
+		0x2e, 0x5c, 0x08, 0xc8, 0x92, 0x42, 0xbf, 0x49, 0xb9, 0xd5, 0xd5, 0xd8, 0x01, 0x39, 0x5e, 0x4e,
+		0xbe, 0x89, 0x97, 0xda, 0xc6, 0x5a, 0x8b, 0xee, 0x99, 0x9a, 0x9d, 0x0e, 0x36, 0x6c, 0x4b, 0x78,
+		0xa9, 0xbc, 0xbc, 0xc8, 0x8b, 0xd1, 0x03, 0x30, 0x67, 0xf7, 0x34, 0xbd, 0xed, 0x83, 0x0d, 0x51,
+		0x58, 0x59, 0x54, 0x38, 0xc0, 0xab, 0x70, 0x5c, 0xd0, 0x6d, 0x61, 0x5b, 0x6b, 0xee, 0xe2, 0x96,
+		0x8b, 0x14, 0xa1, 0x67, 0x23, 0x8e, 0x71, 0x80, 0x12, 0xaf, 0x17, 0xb8, 0xa7, 0xfb, 0xbe, 0xb3,
+		0xe9, 0x3b, 0x08, 0xf3, 0xb3, 0xe9, 0x67, 0xc7, 0x9c, 0x4d, 0x1f, 0x3c, 0x47, 0xec, 0x39, 0x98,
+		0x7e, 0x7a, 0x04, 0x8a, 0x5f, 0xa2, 0xae, 0xbb, 0xf9, 0xf9, 0x00, 0xcc, 0x89, 0xcd, 0xe5, 0x96,
+		0x33, 0x46, 0xeb, 0x00, 0x9a, 0x61, 0x98, 0xb6, 0x77, 0x94, 0x86, 0xe3, 0x81, 0x21, 0xbc, 0xe5,
+		0xbc, 0x83, 0xa4, 0x78, 0x08, 0x64, 0xbf, 0x22, 0x01, 0xb8, 0x55, 0x63, 0x87, 0x6b, 0x11, 0x12,
+		0xbc, 0x57, 0xf4, 0x7c, 0x3f, 0xcb, 0xc1, 0x02, 0x2b, 0xba, 0xa4, 0xb7, 0xe9, 0xa9, 0x91, 0x2d,
+		0xbc, 0xa3, 0x1b, 0xfc, 0xb8, 0x1b, 0xfb, 0x10, 0xa7, 0x46, 0x42, 0xee, 0x71, 0x50, 0x05, 0x62,
+		0x16, 0xee, 0x68, 0x86, 0xad, 0x37, 0xf9, 0x64, 0x3d, 0x7f, 0x28, 0xe6, 0x97, 0xeb, 0x1c, 0x5b,
+		0x71, 0xe8, 0xe4, 0x4e, 0x41, 0x4c, 0x94, 0x3a, 0x4b, 0xd3, 0x0c, 0x8a, 0x42, 0xb0, 0x5e, 0x26,
+		0x8b, 0x33, 0x5d, 0x21, 0x2a, 0xf9, 0xba, 0x1c, 0x38, 0xfd, 0xc9, 0x00, 0x44, 0x85, 0xf5, 0x98,
+		0x87, 0x74, 0xb9, 0x54, 0x19, 0x58, 0xe5, 0xe6, 0x21, 0x25, 0x0a, 0xb9, 0x95, 0x7f, 0x5f, 0xd4,
+		0x5b, 0xb8, 0xa1, 0xd4, 0x1a, 0xb5, 0x15, 0xf9, 0x8f, 0x87, 0x0b, 0x1f, 0x91, 0x5f, 0x8f, 0xa2,
+		0x39, 0x48, 0x8a, 0xc2, 0x95, 0x87, 0x57, 0x1e, 0x91, 0xdf, 0x18, 0x2c, 0x7a, 0x54, 0xfe, 0x12,
+		0x4d, 0xff, 0x89, 0xa2, 0xb3, 0x6a, 0x83, 0x2c, 0x55, 0xb5, 0xea, 0xda, 0x75, 0x59, 0xf2, 0x56,
+		0xac, 0x78, 0x2a, 0x02, 0xe8, 0x4e, 0x38, 0x26, 0x2a, 0x2e, 0x5c, 0xb8, 0x70, 0xe1, 0x31, 0x4f,
+		0xe5, 0xad, 0x0f, 0x44, 0x06, 0xab, 0x1f, 0xf7, 0x54, 0x7f, 0x64, 0xb8, 0xfa, 0x82, 0xa7, 0xfa,
+		0xc7, 0x3f, 0x10, 0x41, 0xf3, 0x90, 0x10, 0xd5, 0xeb, 0xf9, 0x67, 0xe5, 0xaf, 0x7f, 0xfd, 0xeb,
+		0x5f, 0x8f, 0x16, 0xbe, 0x03, 0xe6, 0x9b, 0x66, 0x67, 0x70, 0x68, 0x0a, 0xf2, 0xc0, 0xd9, 0x15,
+		0xeb, 0x8a, 0xf4, 0xdc, 0x43, 0x1c, 0x68, 0xc7, 0x6c, 0x6b, 0xc6, 0xce, 0xb2, 0xd9, 0xdb, 0x71,
+		0x2f, 0x92, 0x90, 0x38, 0xc4, 0xf2, 0x5c, 0x27, 0xe9, 0x6e, 0xfd, 0xb5, 0x24, 0x7d, 0x3c, 0x10,
+		0xbc, 0xbc, 0x51, 0xf8, 0xe9, 0x40, 0xf6, 0x32, 0x43, 0xdc, 0x10, 0x03, 0xaf, 0xe0, 0xed, 0x36,
+		0x6e, 0x92, 0xd1, 0x81, 0x3f, 0x79, 0x00, 0x16, 0x76, 0xcc, 0x1d, 0x93, 0x52, 0x3a, 0x43, 0xfe,
+		0xe2, 0x37, 0x51, 0xe2, 0x4e, 0x69, 0x76, 0xe2, 0xb5, 0x95, 0xd5, 0x2a, 0xcc, 0x73, 0x60, 0x95,
+		0x86, 0x45, 0x6c, 0x7b, 0x1d, 0x1d, 0x78, 0x44, 0x2b, 0xf3, 0xf3, 0x7f, 0x44, 0xf3, 0x59, 0xca,
+		0x1c, 0x47, 0x25, 0x75, 0x6c, 0x07, 0x7e, 0x55, 0x81, 0x23, 0x3e, 0x7a, 0x2c, 0x24, 0xc5, 0xbd,
+		0x09, 0x14, 0xff, 0x0d, 0xa7, 0x38, 0xef, 0xa1, 0x58, 0xe7, 0xa8, 0xab, 0x45, 0x98, 0x3d, 0x0c,
+		0xad, 0x7f, 0xcb, 0x69, 0x25, 0xb1, 0x97, 0xc8, 0x65, 0x48, 0x53, 0x22, 0xcd, 0xbe, 0x65, 0x9b,
+		0x1d, 0x1a, 0xef, 0x1f, 0x4c, 0xe6, 0xdf, 0xfd, 0x11, 0xb3, 0xaa, 0x29, 0x82, 0x56, 0x74, 0xb0,
+		0x56, 0x57, 0x81, 0x86, 0x77, 0x2d, 0xdc, 0x6c, 0x4f, 0xa0, 0xf0, 0x1b, 0x9c, 0x11, 0x07, 0x7e,
+		0xf5, 0x1a, 0xf1, 0xf6, 0xfb, 0x1d, 0x1a, 0x8e, 0x7b, 0x39, 0x99, 0x7c, 0x9e, 0x2b, 0xf3, 0xdb,
+		0xef, 0x65, 0x86, 0x7b, 0xde, 0x21, 0xe0, 0xe1, 0xc9, 0x33, 0x8a, 0x3b, 0xd8, 0xb6, 0x71, 0xcf,
+		0x52, 0xb5, 0xf6, 0x28, 0xf6, 0x3c, 0x07, 0x62, 0x32, 0x3f, 0xf2, 0x55, 0xff, 0x28, 0x5e, 0x66,
+		0x98, 0xf9, 0x76, 0x7b, 0x75, 0x13, 0x8e, 0x8d, 0xd0, 0x8a, 0x29, 0x68, 0xfe, 0x28, 0xa7, 0xb9,
+		0x30, 0xa4, 0x19, 0x84, 0xec, 0x06, 0x88, 0x72, 0x67, 0x2c, 0xa7, 0xa0, 0xf9, 0x61, 0x4e, 0x13,
+		0x71, 0x5c, 0x31, 0xa4, 0x84, 0xe2, 0x55, 0x98, 0xbb, 0x89, 0x7b, 0x5b, 0xa6, 0xc5, 0x0f, 0x21,
+		0x4d, 0x41, 0xee, 0xc7, 0x38, 0xb9, 0x34, 0x47, 0xa4, 0xa7, 0x92, 0x08, 0xad, 0x0b, 0x10, 0xdb,
+		0xd6, 0x9a, 0x78, 0x0a, 0x12, 0xb7, 0x38, 0x89, 0x28, 0x81, 0x27, 0xa8, 0x79, 0x48, 0xee, 0x98,
+		0x3c, 0x23, 0x33, 0x19, 0xfd, 0x23, 0x1c, 0x3d, 0x21, 0x70, 0x38, 0x89, 0xae, 0xd9, 0xed, 0xb7,
+		0x35, 0x7b, 0x1a, 0x0e, 0x7e, 0x5c, 0x90, 0x10, 0x38, 0x9c, 0xc4, 0x21, 0xc4, 0xfa, 0x51, 0x41,
+		0xc2, 0xf2, 0xc8, 0xf3, 0x49, 0x48, 0x98, 0x46, 0x7b, 0xdf, 0x34, 0xa6, 0x61, 0xe2, 0x63, 0x9c,
+		0x02, 0x70, 0x14, 0x42, 0xe0, 0x22, 0xc4, 0xa7, 0x1d, 0x88, 0x9f, 0xf8, 0xaa, 0x98, 0x1e, 0x62,
+		0x04, 0x2e, 0x43, 0x5a, 0x18, 0x28, 0xdd, 0x34, 0xa6, 0x20, 0xf1, 0x93, 0x9c, 0x44, 0xca, 0x83,
+		0xc6, 0xbb, 0x61, 0x63, 0xcb, 0xde, 0xc1, 0xd3, 0x10, 0xf9, 0xa4, 0xe8, 0x06, 0x47, 0xe1, 0xa2,
+		0xdc, 0xc2, 0x46, 0x73, 0x77, 0x3a, 0x0a, 0x9f, 0x12, 0xa2, 0x14, 0x38, 0x84, 0x44, 0x11, 0x66,
+		0x3b, 0x5a, 0xcf, 0xda, 0xd5, 0xda, 0x53, 0x0d, 0xc7, 0x4f, 0x71, 0x1a, 0x49, 0x07, 0x89, 0x4b,
+		0xa4, 0x6f, 0x1c, 0x86, 0xcc, 0x4f, 0x0b, 0x89, 0x78, 0xd0, 0xf8, 0xd4, 0xb3, 0x6c, 0xea, 0x70,
+		0x1f, 0x86, 0xda, 0xcf, 0x88, 0xa9, 0xc7, 0x70, 0xd7, 0xbd, 0x14, 0x2f, 0x42, 0xdc, 0xd2, 0x5f,
+		0x9c, 0x8a, 0xcc, 0xcf, 0x8a, 0x91, 0xa6, 0x08, 0x04, 0xf9, 0x3a, 0x1c, 0x1f, 0xb9, 0x4c, 0x4c,
+		0x41, 0xec, 0xe7, 0x38, 0xb1, 0xa3, 0x23, 0x96, 0x0a, 0x6e, 0x12, 0x0e, 0x4b, 0xf2, 0x1f, 0x09,
+		0x93, 0x80, 0x07, 0x68, 0x6d, 0xc0, 0x42, 0xdf, 0xb0, 0xb4, 0xed, 0xc3, 0x49, 0xed, 0x1f, 0x0b,
+		0xa9, 0x31, 0x5c, 0x9f, 0xd4, 0x1a, 0x70, 0x94, 0x53, 0x3c, 0xdc, 0xb8, 0x7e, 0x5a, 0x18, 0x56,
+		0x86, 0xbd, 0xe9, 0x1f, 0xdd, 0x6f, 0x81, 0xac, 0x23, 0x4e, 0xe1, 0x1d, 0x5b, 0x6a, 0x47, 0xeb,
+		0x4e, 0x41, 0xf9, 0xe7, 0x39, 0x65, 0x61, 0xf1, 0x1d, 0xf7, 0xda, 0x5a, 0xd7, 0xba, 0x84, 0xf8,
+		0xb3, 0x90, 0x11, 0xc4, 0xfb, 0x46, 0x0f, 0x37, 0xcd, 0x1d, 0x43, 0x7f, 0x11, 0xb7, 0xa6, 0x20,
+		0xfd, 0x99, 0x81, 0xa1, 0xda, 0xf4, 0xa0, 0x13, 0xca, 0x15, 0x90, 0x1d, 0x5f, 0x45, 0xd5, 0x3b,
+		0x74, 0xe3, 0xea, 0x60, 0x8a, 0xbf, 0x20, 0x46, 0xca, 0xc1, 0xab, 0x50, 0xb4, 0xd5, 0x32, 0xb0,
+		0x6b, 0x0c, 0xd3, 0xaa, 0xe4, 0x67, 0x39, 0xa1, 0x59, 0x17, 0x8b, 0x1b, 0x8e, 0xa6, 0xd9, 0xe9,
+		0x6a, 0xbd, 0x69, 0xec, 0xdf, 0x3f, 0x11, 0x86, 0x83, 0xa3, 0x70, 0xc3, 0x41, 0x3c, 0x3a, 0xb2,
+		0xda, 0x4f, 0x41, 0xe1, 0x17, 0x85, 0xe1, 0x10, 0x38, 0x9c, 0x84, 0x70, 0x18, 0xa6, 0x20, 0xf1,
+		0x4b, 0x82, 0x84, 0xc0, 0x21, 0x24, 0x9e, 0x76, 0x17, 0xda, 0x1e, 0xde, 0xd1, 0x2d, 0x9b, 0x5f,
+		0x34, 0x3a, 0x98, 0xd4, 0x2f, 0x7f, 0xd5, 0xef, 0x84, 0x29, 0x1e, 0x54, 0x62, 0x89, 0x78, 0x06,
+		0x95, 0xee, 0x10, 0x4c, 0x66, 0xec, 0x57, 0x84, 0x25, 0xf2, 0xa0, 0x11, 0xde, 0x3c, 0x1e, 0x22,
+		0x11, 0x7b, 0x93, 0x44, 0x92, 0x53, 0x90, 0xfb, 0xa7, 0x03, 0xcc, 0xd5, 0x05, 0x2e, 0xa1, 0xe9,
+		0xf1, 0x7f, 0xfa, 0xc6, 0x0d, 0xbc, 0x3f, 0x95, 0x76, 0xfe, 0xb3, 0x01, 0xff, 0x67, 0x93, 0x61,
+		0x32, 0x1b, 0x92, 0x1e, 0xf0, 0xa7, 0xd0, 0xa4, 0x5b, 0x88, 0x99, 0xef, 0x7c, 0x93, 0xf7, 0xd7,
+		0xef, 0x4e, 0xad, 0xae, 0x11, 0x25, 0xf7, 0x3b, 0x3d, 0x93, 0x89, 0xbd, 0xf7, 0x4d, 0x47, 0xcf,
+		0x7d, 0x3e, 0xcf, 0xea, 0x25, 0x98, 0xf5, 0x39, 0x3c, 0x93, 0x49, 0xbd, 0x8f, 0x93, 0x4a, 0x7a,
+		0xfd, 0x9d, 0xd5, 0x73, 0x10, 0x22, 0xce, 0xcb, 0x64, 0xf4, 0xef, 0xe6, 0xe8, 0x14, 0x7c, 0xf5,
+		0x09, 0x88, 0x09, 0xa7, 0x65, 0x32, 0xea, 0xf7, 0x70, 0x54, 0x07, 0x85, 0xa0, 0x0b, 0x87, 0x65,
+		0x32, 0xfa, 0xdf, 0x13, 0xe8, 0x02, 0x85, 0xa0, 0x4f, 0x2f, 0xc2, 0x5f, 0x7b, 0x7f, 0x88, 0x2f,
+		0x3a, 0x42, 0x76, 0x17, 0x21, 0xca, 0x3d, 0x95, 0xc9, 0xd8, 0xdf, 0xcb, 0x1b, 0x17, 0x18, 0xab,
+		0x8f, 0x41, 0x78, 0x4a, 0x81, 0x7f, 0x80, 0xa3, 0x32, 0xf8, 0xd5, 0x22, 0x24, 0x3c, 0xde, 0xc9,
+		0x64, 0xf4, 0xef, 0xe7, 0xe8, 0x5e, 0x2c, 0xc2, 0x3a, 0xf7, 0x4e, 0x26, 0x13, 0xf8, 0xfb, 0x82,
+		0x75, 0x8e, 0x41, 0xc4, 0x26, 0x1c, 0x93, 0xc9, 0xd8, 0x1f, 0x14, 0x52, 0x17, 0x28, 0xab, 0x4f,
+		0x42, 0xdc, 0x59, 0x6c, 0x26, 0xe3, 0xff, 0x00, 0xc7, 0x77, 0x71, 0x88, 0x04, 0x3c, 0x8b, 0xdd,
+		0x64, 0x12, 0xff, 0x40, 0x48, 0xc0, 0x83, 0x45, 0xa6, 0xd1, 0xa0, 0x03, 0x33, 0x99, 0xd2, 0x87,
+		0xc4, 0x34, 0x1a, 0xf0, 0x5f, 0xc8, 0x68, 0x52, 0x9b, 0x3f, 0x99, 0xc4, 0x0f, 0x8a, 0xd1, 0xa4,
+		0xf0, 0x84, 0x8d, 0x41, 0x8f, 0x60, 0x32, 0x8d, 0x1f, 0x16, 0x6c, 0x0c, 0x38, 0x04, 0xab, 0x1b,
+		0x80, 0x86, 0xbd, 0x81, 0xc9, 0xf4, 0x5e, 0xe5, 0xf4, 0xe6, 0x86, 0x9c, 0x81, 0xd5, 0x67, 0xe0,
+		0xe8, 0x68, 0x4f, 0x60, 0x32, 0xd5, 0x1f, 0x79, 0x73, 0x20, 0x76, 0xf3, 0x3a, 0x02, 0xab, 0x0d,
+		0x77, 0x49, 0xf1, 0x7a, 0x01, 0x93, 0xc9, 0xfe, 0xe8, 0x9b, 0x7e, 0xc3, 0xed, 0x75, 0x02, 0x56,
+		0xf3, 0x00, 0xee, 0x02, 0x3c, 0x99, 0xd6, 0x8f, 0x71, 0x5a, 0x1e, 0x24, 0x32, 0x35, 0xf8, 0xfa,
+		0x3b, 0x19, 0xff, 0x96, 0x98, 0x1a, 0x1c, 0x83, 0x4c, 0x0d, 0xb1, 0xf4, 0x4e, 0xc6, 0xfe, 0x88,
+		0x98, 0x1a, 0x02, 0x85, 0x68, 0xb6, 0x67, 0x75, 0x9b, 0x4c, 0xe1, 0x63, 0x42, 0xb3, 0x3d, 0x58,
+		0xab, 0x55, 0x98, 0x1b, 0x5a, 0x10, 0x27, 0x93, 0xfa, 0x38, 0x27, 0x25, 0x0f, 0xae, 0x87, 0xde,
+		0xc5, 0x8b, 0x2f, 0x86, 0x93, 0xa9, 0x7d, 0x62, 0x60, 0xf1, 0xe2, 0x6b, 0xe1, 0xea, 0x45, 0x88,
+		0x19, 0xfd, 0x76, 0x9b, 0x4c, 0x1e, 0x74, 0xf0, 0x45, 0xd3, 0xcc, 0x97, 0xbe, 0xc6, 0xa5, 0x23,
+		0x10, 0x56, 0xcf, 0x41, 0x18, 0x77, 0xb6, 0x70, 0x6b, 0x12, 0xe6, 0x97, 0xbf, 0x26, 0x0c, 0x26,
+		0x81, 0x5e, 0x7d, 0x12, 0x80, 0xa5, 0x46, 0xe8, 0x61, 0xed, 0x09, 0xb8, 0x5f, 0xf9, 0x1a, 0xbf,
+		0xd9, 0xe5, 0xa2, 0xb8, 0x04, 0xd8, 0x3d, 0xb1, 0x83, 0x09, 0x7c, 0xd5, 0x4f, 0x80, 0x8e, 0xc8,
+		0x05, 0x88, 0x3e, 0x6f, 0x99, 0x86, 0xad, 0xed, 0x4c, 0xc2, 0xfe, 0x13, 0x8e, 0x2d, 0xe0, 0x89,
+		0xc0, 0x3a, 0x66, 0x0f, 0xdb, 0xda, 0x8e, 0x35, 0x09, 0xf7, 0xbf, 0x71, 0x5c, 0x07, 0x81, 0x20,
+		0x37, 0x35, 0xcb, 0x9e, 0xa6, 0xdf, 0x7f, 0x2a, 0x90, 0x05, 0x02, 0x61, 0x9a, 0xfc, 0x7d, 0x03,
+		0xef, 0x4f, 0xc2, 0xfd, 0x33, 0xc1, 0x34, 0x87, 0x5f, 0x7d, 0x02, 0xe2, 0xe4, 0x4f, 0x76, 0x5d,
+		0x73, 0x02, 0xf2, 0x9f, 0x73, 0x64, 0x17, 0x83, 0xb4, 0x6c, 0xd9, 0x2d, 0x5b, 0x9f, 0x2c, 0xec,
+		0xbf, 0xe0, 0x23, 0x2d, 0xe0, 0x57, 0xf3, 0x90, 0xb0, 0xec, 0x56, 0xab, 0xcf, 0xfd, 0xd3, 0x09,
+		0xe8, 0x7f, 0xf9, 0x35, 0x27, 0x65, 0xe1, 0xe0, 0x90, 0xd1, 0x7e, 0xe1, 0x86, 0xdd, 0x35, 0xe9,
+		0xf1, 0x9e, 0x49, 0x14, 0xde, 0xe4, 0x14, 0x3c, 0x28, 0xab, 0x45, 0x48, 0x92, 0xbe, 0x88, 0x53,
+		0x12, 0x93, 0x48, 0xfc, 0x15, 0x17, 0x80, 0x0f, 0xa9, 0xf0, 0xed, 0xbf, 0xf1, 0x85, 0x93, 0xd2,
+		0xe7, 0xbf, 0x70, 0x52, 0xfa, 0xaf, 0x5f, 0x38, 0x29, 0x7d, 0xf0, 0x8b, 0x27, 0x67, 0x3e, 0xff,
+		0xc5, 0x93, 0x33, 0xbf, 0xf7, 0xc5, 0x93, 0x33, 0xa3, 0xb3, 0xc4, 0x70, 0xd9, 0xbc, 0x6c, 0xb2,
+		0xfc, 0xf0, 0x73, 0xf7, 0xec, 0xe8, 0xf6, 0x6e, 0x7f, 0x6b, 0xb9, 0x69, 0x76, 0xce, 0x34, 0x4d,
+		0xab, 0x63, 0x5a, 0x67, 0xfc, 0x79, 0x5d, 0xfa, 0x17, 0xfc, 0x2f, 0x89, 0xc4, 0xcc, 0xfe, 0x74,
+		0xae, 0x66, 0xec, 0x8f, 0x7b, 0x7e, 0xe8, 0x3c, 0x04, 0xf3, 0xc6, 0x3e, 0x3a, 0xce, 0x0c, 0x9c,
+		0xda, 0xef, 0xb5, 0xf9, 0x9d, 0xc1, 0x28, 0xf9, 0xde, 0xec, 0xb5, 0xfd, 0xe7, 0xc5, 0x93, 0xfc,
+		0xbc, 0x78, 0xe1, 0xfb, 0xa5, 0xc3, 0xf5, 0x24, 0x96, 0x37, 0xf6, 0x69, 0x47, 0x36, 0xa4, 0xe7,
+		0x1e, 0x9c, 0x98, 0xe7, 0xbe, 0x61, 0x98, 0x2f, 0x18, 0x84, 0xed, 0xee, 0x96, 0xc8, 0x71, 0x9f,
+		0x1c, 0xcc, 0x71, 0x3f, 0x83, 0xdb, 0xed, 0xa7, 0x08, 0x5c, 0x83, 0xa0, 0x6c, 0x45, 0xd8, 0xf5,
+		0x74, 0xf8, 0x50, 0x00, 0x4e, 0x0e, 0xa5, 0xb3, 0xb9, 0x12, 0x8c, 0x13, 0xc2, 0x2a, 0xc4, 0x4a,
+		0x42, 0xb7, 0x32, 0x10, 0xb5, 0x70, 0xd3, 0x34, 0x5a, 0xec, 0xe0, 0x6f, 0x50, 0x11, 0x9f, 0x44,
+		0x10, 0x86, 0x66, 0x98, 0x16, 0xbf, 0x75, 0xcb, 0x3e, 0x0a, 0x1f, 0x3e, 0xa4, 0x20, 0x66, 0x45,
+		0x4b, 0x42, 0x1a, 0x67, 0xa7, 0x94, 0x86, 0xe8, 0x84, 0x2f, 0xf3, 0x3f, 0xad, 0x54, 0x7e, 0x38,
+		0x00, 0x8b, 0x83, 0x52, 0x21, 0x33, 0xcb, 0xb2, 0xb5, 0x4e, 0x77, 0x9c, 0x58, 0x2e, 0x42, 0xbc,
+		0x21, 0x60, 0x0e, 0x2d, 0x97, 0x5b, 0x87, 0x94, 0x4b, 0xca, 0x69, 0x4a, 0x08, 0x66, 0x65, 0x4a,
+		0xc1, 0x38, 0xfd, 0xb8, 0x2d, 0xc9, 0xfc, 0xcf, 0x08, 0x1c, 0x67, 0xd3, 0x49, 0x65, 0x53, 0x89,
+		0x7d, 0x70, 0x99, 0x24, 0xbd, 0x55, 0x93, 0xf7, 0x49, 0x72, 0x4f, 0xc1, 0x7c, 0x85, 0x58, 0x0b,
+		0x12, 0x05, 0xb9, 0x3b, 0x3c, 0x23, 0x2f, 0x26, 0x2f, 0xf9, 0x1c, 0x7e, 0xbe, 0x13, 0xe8, 0x2d,
+		0xca, 0x7d, 0xa7, 0x04, 0x72, 0xbd, 0xa9, 0xb5, 0xb5, 0xde, 0x37, 0x4a, 0x0a, 0x3d, 0x06, 0xc0,
+		0x8e, 0x95, 0x39, 0x4f, 0x0a, 0xa5, 0x56, 0x32, 0xcb, 0xde, 0xce, 0x2d, 0xb3, 0x96, 0xe8, 0xa5,
+		0x9d, 0x38, 0x85, 0x25, 0x7f, 0x9e, 0x7e, 0x16, 0xc0, 0xad, 0x40, 0x27, 0xe0, 0x58, 0xbd, 0x98,
+		0x5f, 0xcb, 0x2b, 0xe2, 0xc4, 0x4d, 0x7d, 0xa3, 0x5c, 0x64, 0x2f, 0x7c, 0xcc, 0xa0, 0xa3, 0x80,
+		0xbc, 0x95, 0xce, 0x45, 0x87, 0x23, 0x30, 0xe7, 0x2d, 0x67, 0xcf, 0x2d, 0x04, 0x88, 0xa7, 0xa8,
+		0x77, 0xba, 0x6d, 0x4c, 0xb7, 0x86, 0x55, 0x5d, 0x48, 0x6d, 0xb2, 0x13, 0xf2, 0x9b, 0xbf, 0xcb,
+		0xae, 0xe0, 0xcf, 0xbb, 0xe8, 0x8e, 0xcc, 0x57, 0xd7, 0x60, 0x4e, 0x6b, 0x36, 0x71, 0xd7, 0x47,
+		0x72, 0x82, 0xa9, 0x26, 0x04, 0xe9, 0x66, 0x37, 0xc7, 0x74, 0xa9, 0x3d, 0x06, 0x11, 0x8b, 0xf6,
+		0x7e, 0x12, 0x89, 0xcf, 0x71, 0x12, 0x1c, 0x7c, 0xd5, 0x80, 0x39, 0xf6, 0xe2, 0x0c, 0xf6, 0xb0,
+		0x71, 0x70, 0x9e, 0xe1, 0x9f, 0xff, 0xc2, 0xc3, 0x74, 0x0f, 0xfa, 0x2e, 0xff, 0xb0, 0x8c, 0x50,
+		0x27, 0x45, 0xe6, 0xb4, 0x5d, 0x46, 0x31, 0xa4, 0x44, 0x7b, 0x9c, 0xe1, 0x83, 0x1b, 0xfb, 0x55,
+		0xde, 0xd8, 0xc9, 0x51, 0x3a, 0xe0, 0x69, 0x69, 0x96, 0x53, 0x65, 0x15, 0x85, 0xf2, 0xb8, 0x39,
+		0xfd, 0xdc, 0x03, 0xc3, 0xab, 0x13, 0xfb, 0xef, 0x21, 0x4a, 0xf9, 0xa2, 0xb7, 0x19, 0x67, 0xee,
+		0x7d, 0x38, 0x04, 0x73, 0x5a, 0x47, 0x37, 0xcc, 0x33, 0xf4, 0x5f, 0x3e, 0xe7, 0xc2, 0xf4, 0x63,
+		0x8a, 0x4d, 0xc9, 0xf3, 0x6c, 0x2a, 0x4c, 0xd6, 0x98, 0x3f, 0xff, 0xbe, 0x9f, 0x0c, 0xbb, 0xd3,
+		0x65, 0x75, 0x7d, 0xf8, 0x48, 0xe1, 0x64, 0x1a, 0x7f, 0x21, 0x68, 0x0c, 0x9e, 0x10, 0x5c, 0x7d,
+		0x27, 0xc4, 0x1c, 0x32, 0x93, 0x3c, 0x13, 0x41, 0xc4, 0xc1, 0x20, 0x7e, 0x09, 0x9b, 0x99, 0xd3,
+		0x78, 0xa1, 0x6f, 0x0a, 0x7c, 0x36, 0x43, 0xab, 0xa4, 0x37, 0x97, 0x21, 0xd5, 0x32, 0x0d, 0x5b,
+		0x35, 0x3b, 0xba, 0x8d, 0x3b, 0x5d, 0x7b, 0xa2, 0x5f, 0xf7, 0x57, 0x8c, 0x48, 0x4c, 0x99, 0x25,
+		0x78, 0x35, 0x81, 0x46, 0x38, 0x61, 0x0f, 0xce, 0x4c, 0xc3, 0xc9, 0x7f, 0x77, 0x38, 0xa1, 0x38,
+		0x84, 0x93, 0xdb, 0xd2, 0x0e, 0xab, 0x75, 0x83, 0x1b, 0x73, 0x7b, 0x8f, 0x69, 0x81, 0xa3, 0x1d,
+		0xff, 0x2a, 0x04, 0x27, 0x39, 0xf0, 0x96, 0x66, 0xe1, 0x33, 0x37, 0xcf, 0x6e, 0x61, 0x5b, 0x3b,
+		0x7b, 0xa6, 0x69, 0xea, 0x62, 0x25, 0x9f, 0xe7, 0xc6, 0x9a, 0xd4, 0x2f, 0xf3, 0xfa, 0xec, 0xc8,
+		0xed, 0xee, 0xec, 0x78, 0x23, 0x9f, 0x1d, 0xd6, 0xc1, 0x5c, 0x1b, 0x42, 0x45, 0x53, 0xa7, 0x97,
+		0xe5, 0x5a, 0xd8, 0x30, 0x3b, 0xdc, 0xdc, 0xb2, 0x0f, 0x74, 0x05, 0x22, 0x5a, 0xc7, 0xec, 0x1b,
+		0x36, 0x33, 0xb5, 0x85, 0x87, 0x7f, 0xe3, 0xb5, 0xc5, 0x99, 0xff, 0xfc, 0xda, 0xe2, 0x11, 0x46,
+		0xd6, 0x6a, 0xdd, 0x58, 0xd6, 0xcd, 0x33, 0x1d, 0xcd, 0xde, 0x25, 0xd3, 0xf7, 0x77, 0x3e, 0xfb,
+		0x10, 0xf0, 0xf6, 0x2a, 0x86, 0xfd, 0xa9, 0xd7, 0x3f, 0x7d, 0x5a, 0x52, 0x38, 0xfe, 0x6a, 0xe8,
+		0x8d, 0x8f, 0x2e, 0x4a, 0xb9, 0x2e, 0x44, 0x4b, 0xb8, 0x79, 0x40, 0x83, 0x95, 0x81, 0x06, 0xcf,
+		0xf2, 0x06, 0x4f, 0x0c, 0x37, 0xc8, 0x2e, 0xe1, 0x94, 0x70, 0xd3, 0xd3, 0x6c, 0x09, 0x37, 0x07,
+		0x5a, 0xac, 0x40, 0xac, 0x62, 0xd8, 0xec, 0xd5, 0x8c, 0x27, 0x20, 0xa8, 0x1b, 0xec, 0xb2, 0x75,
+		0xbc, 0xf0, 0xc0, 0x21, 0xba, 0xa2, 0x10, 0xbc, 0x5c, 0x0d, 0x62, 0x25, 0xdc, 0x64, 0xa4, 0x8a,
+		0x10, 0x6c, 0xe1, 0x26, 0x27, 0x75, 0x1b, 0x4c, 0x12, 0xec, 0x42, 0xe9, 0xf7, 0xfe, 0xf0, 0xe4,
+		0xcc, 0x4b, 0x5f, 0x38, 0x39, 0x33, 0x56, 0x9d, 0x72, 0x93, 0xd5, 0xc9, 0xd1, 0xa2, 0x9f, 0x0c,
+		0xc1, 0x9d, 0xf4, 0xd9, 0xa5, 0x5e, 0x47, 0x37, 0xec, 0x33, 0xcd, 0xde, 0x7e, 0xd7, 0x36, 0x89,
+		0x51, 0x31, 0xb7, 0xb9, 0x12, 0xcd, 0xb9, 0xd5, 0xcb, 0xac, 0x7a, 0xb4, 0x0a, 0xe5, 0xb6, 0x21,
+		0xbc, 0x41, 0xf0, 0xc8, 0x20, 0xd9, 0xa6, 0xad, 0xb5, 0xb9, 0x27, 0xc4, 0x3e, 0x48, 0x29, 0x7b,
+		0xaa, 0x29, 0xc0, 0x4a, 0x75, 0xf1, 0x4a, 0x53, 0x1b, 0x6b, 0xdb, 0xec, 0xc5, 0x8b, 0x20, 0x75,
+		0xa1, 0x63, 0xa4, 0x80, 0x3e, 0x6e, 0xb1, 0x00, 0x61, 0xad, 0xcf, 0x4e, 0x5b, 0x05, 0x89, 0x6f,
+		0x4d, 0x3f, 0x72, 0x4f, 0x41, 0x94, 0xef, 0xe9, 0x23, 0x19, 0x82, 0x37, 0xf0, 0x3e, 0x6d, 0x27,
+		0xa9, 0x90, 0x3f, 0xd1, 0x32, 0x84, 0x29, 0xf3, 0xfc, 0xa2, 0x51, 0x66, 0x79, 0x88, 0xfb, 0x65,
+		0xca, 0xa4, 0xc2, 0xc0, 0x72, 0x57, 0x21, 0x56, 0x32, 0x89, 0x66, 0xfb, 0xa9, 0xc5, 0x19, 0x35,
+		0xca, 0x73, 0xb7, 0x6f, 0x8b, 0xcb, 0xa0, 0xf4, 0x03, 0x1d, 0x85, 0x08, 0x7b, 0x01, 0x85, 0x9f,
+		0x18, 0xe3, 0x5f, 0xb9, 0x22, 0x44, 0x29, 0xed, 0x5a, 0xd7, 0x79, 0x56, 0x4c, 0xf2, 0x3c, 0x2b,
+		0xc6, 0xc9, 0x07, 0x5c, 0x66, 0x11, 0x84, 0x5a, 0x9a, 0xad, 0xf1, 0x7e, 0xd3, 0xbf, 0x73, 0xef,
+		0x82, 0x18, 0x27, 0x62, 0xa1, 0x15, 0x08, 0x9a, 0x5d, 0x71, 0x20, 0x32, 0x3b, 0xae, 0x2b, 0xb5,
+		0x6e, 0x21, 0x44, 0x74, 0x49, 0x21, 0xc0, 0x85, 0xea, 0x58, 0xb5, 0x78, 0xd4, 0xa7, 0x16, 0x1d,
+		0x6c, 0x6f, 0x6d, 0xdb, 0xee, 0x1f, 0x6c, 0x38, 0x87, 0x54, 0xc1, 0x51, 0x94, 0x5b, 0x01, 0x38,
+		0xe9, 0xa9, 0xbd, 0x89, 0x7b, 0x96, 0x6e, 0x1a, 0x4c, 0x9b, 0xb8, 0xa6, 0x20, 0x0f, 0x83, 0xbc,
+		0x7e, 0x8c, 0xaa, 0x3c, 0x01, 0xc1, 0x7c, 0xb7, 0x8b, 0xb2, 0x10, 0xa3, 0xdf, 0x4d, 0x93, 0xe9,
+		0x4a, 0x48, 0x71, 0xbe, 0x49, 0x9d, 0x65, 0x6e, 0xdb, 0x2f, 0x68, 0x3d, 0xe7, 0x81, 0x30, 0xf1,
+		0x9d, 0xbb, 0x00, 0xf1, 0xa2, 0x69, 0x58, 0xd8, 0xb0, 0xfa, 0xd4, 0xbf, 0xde, 0x6a, 0x9b, 0xcd,
+		0x1b, 0x9c, 0x02, 0xfb, 0x20, 0xc2, 0xd6, 0xba, 0x5d, 0x8a, 0x19, 0x52, 0xc8, 0x9f, 0x6c, 0x66,
+		0x17, 0x6a, 0x63, 0xc5, 0x73, 0xee, 0x70, 0xe2, 0xe1, 0x1d, 0x74, 0x1d, 0x65, 0x09, 0xee, 0x18,
+		0x9e, 0x48, 0x37, 0xf0, 0xbe, 0x75, 0xd8, 0x79, 0xf4, 0x2c, 0xc4, 0x37, 0xe8, 0x33, 0xad, 0x4f,
+		0xe1, 0x7d, 0x94, 0x85, 0x28, 0x6e, 0xad, 0x9c, 0x3b, 0x77, 0xf6, 0x02, 0xd3, 0xf2, 0x2b, 0x33,
+		0x8a, 0x28, 0x40, 0x27, 0x21, 0x6e, 0xe1, 0x66, 0x77, 0xe5, 0xdc, 0xf9, 0x1b, 0x67, 0x99, 0x5a,
+		0x5d, 0x99, 0x51, 0xdc, 0xa2, 0xd5, 0x18, 0xe9, 0xf1, 0x1b, 0x1f, 0x5b, 0x94, 0x0a, 0x61, 0x08,
+		0x5a, 0xfd, 0xce, 0x37, 0x4d, 0x37, 0xfe, 0x2c, 0x02, 0x4b, 0x9e, 0x5a, 0xb6, 0x60, 0xf1, 0x1b,
+		0x11, 0xce, 0xd3, 0xbe, 0xb2, 0xa7, 0xff, 0x14, 0x62, 0xcc, 0x4a, 0x74, 0xa0, 0x14, 0x73, 0x9f,
+		0x91, 0x20, 0x79, 0x4d, 0x50, 0xae, 0x63, 0x1b, 0x5d, 0x04, 0x70, 0x5a, 0x12, 0x53, 0xe5, 0xc4,
+		0xf2, 0x60, 0x5b, 0xcb, 0x0e, 0x8e, 0xe2, 0x01, 0x47, 0x8f, 0x51, 0x05, 0xec, 0x9a, 0x16, 0x7f,
+		0x2c, 0x6a, 0x02, 0xaa, 0x03, 0x8c, 0x1e, 0x04, 0x44, 0xad, 0x9a, 0x7a, 0xd3, 0xb4, 0x75, 0x63,
+		0x47, 0xed, 0x9a, 0x2f, 0xf0, 0x27, 0xf8, 0x82, 0x8a, 0x4c, 0x6b, 0xae, 0xd1, 0x8a, 0x0d, 0x52,
+		0x4e, 0x98, 0x8e, 0x3b, 0x54, 0x48, 0xa8, 0xa8, 0xb5, 0x5a, 0x3d, 0x6c, 0x59, 0xdc, 0x70, 0x89,
+		0x4f, 0x74, 0x11, 0xa2, 0xdd, 0xfe, 0x96, 0x2a, 0xac, 0x44, 0x62, 0xe5, 0x8e, 0x51, 0x73, 0x5e,
+		0xe8, 0x06, 0x9f, 0xf5, 0x91, 0x6e, 0x7f, 0x8b, 0x68, 0xca, 0x5d, 0x90, 0x1c, 0xc1, 0x4c, 0xe2,
+		0xa6, 0xcb, 0x07, 0x7d, 0x19, 0x98, 0xf7, 0x40, 0xed, 0xf6, 0x74, 0xb3, 0xa7, 0xdb, 0xfb, 0xf4,
+		0xd0, 0x64, 0x50, 0x91, 0x45, 0xc5, 0x06, 0x2f, 0xcf, 0xdd, 0x80, 0x74, 0x9d, 0x86, 0x10, 0x2e,
+		0xe7, 0xe7, 0x5c, 0xfe, 0xa4, 0xc9, 0xfc, 0x8d, 0xe5, 0x2c, 0x30, 0xc4, 0xd9, 0xe9, 0xff, 0x24,
+		0x41, 0xa2, 0x40, 0x26, 0x6e, 0xa5, 0x74, 0xa9, 0xad, 0xed, 0xa0, 0xb3, 0x70, 0xa4, 0xb0, 0x56,
+		0x2b, 0x3e, 0xa5, 0x56, 0x4a, 0xea, 0xa5, 0xb5, 0xbc, 0xe7, 0x4c, 0x7f, 0xf6, 0xe8, 0x2b, 0xb7,
+		0x96, 0x90, 0x07, 0x76, 0xd3, 0xa0, 0x71, 0x2e, 0x3a, 0x03, 0x0b, 0x7e, 0x94, 0x7c, 0xa1, 0x5e,
+		0xae, 0x36, 0x64, 0x29, 0x7b, 0xe4, 0x95, 0x5b, 0x4b, 0x73, 0x1e, 0x8c, 0xfc, 0x96, 0x85, 0x0d,
+		0x7b, 0x18, 0xa1, 0x58, 0x5b, 0x5f, 0xaf, 0x34, 0xe4, 0xc0, 0x10, 0x42, 0xd1, 0xec, 0x74, 0x74,
+		0x1b, 0xdd, 0x0f, 0x73, 0x7e, 0x84, 0x6a, 0x65, 0x4d, 0x0e, 0x66, 0xd1, 0x2b, 0xb7, 0x96, 0x52,
+		0x1e, 0xe8, 0xaa, 0xde, 0xce, 0xc6, 0x5e, 0xfe, 0xc4, 0xc9, 0x99, 0x4f, 0xfd, 0xc3, 0x93, 0x52,
+		0x61, 0x7d, 0xec, 0x9c, 0x7b, 0xe4, 0x70, 0x73, 0xce, 0xbf, 0x6e, 0x7f, 0xed, 0x0e, 0x9f, 0xb9,
+		0xe1, 0x3e, 0xa2, 0xc7, 0x18, 0x4f, 0x3b, 0xdd, 0x26, 0xe5, 0x3d, 0xb2, 0x07, 0xbb, 0x07, 0xd9,
+		0x09, 0x8b, 0x42, 0x76, 0xa2, 0x61, 0xc8, 0x5d, 0x80, 0xd9, 0x0d, 0xad, 0x67, 0xd7, 0xb1, 0x7d,
+		0x05, 0x6b, 0x2d, 0xdc, 0xf3, 0xfb, 0x0f, 0xb3, 0xc2, 0x7f, 0x40, 0x10, 0xa2, 0x4e, 0x02, 0x5b,
+		0x3f, 0xe9, 0xdf, 0xb9, 0x5d, 0x08, 0xd1, 0x4b, 0x75, 0x8e, 0x6f, 0xc1, 0x31, 0x98, 0x6f, 0x41,
+		0x56, 0x86, 0x7d, 0x9b, 0x5f, 0x3a, 0x4e, 0x2a, 0xec, 0x03, 0x3d, 0x2a, 0x3c, 0x84, 0xe0, 0xc1,
+		0x1e, 0x02, 0x9f, 0x5e, 0xdc, 0x4f, 0x68, 0x43, 0x94, 0x0f, 0xb1, 0xc3, 0x88, 0xe4, 0x32, 0x82,
+		0xd6, 0x21, 0xdd, 0xd5, 0x7a, 0x36, 0x7d, 0xa2, 0x67, 0x97, 0xf6, 0x82, 0xcf, 0xe0, 0xc5, 0x61,
+		0x7b, 0xe2, 0xeb, 0x2c, 0x6f, 0x65, 0xb6, 0xeb, 0x2d, 0xcc, 0xfd, 0x71, 0x08, 0x22, 0x5c, 0x18,
+		0x4f, 0x40, 0x94, 0x8b, 0x95, 0xcf, 0xb9, 0x3b, 0x97, 0x87, 0x97, 0xd9, 0x65, 0x67, 0x39, 0xe4,
+		0xf4, 0x04, 0x0e, 0xba, 0x17, 0x62, 0xcd, 0x5d, 0x4d, 0x37, 0x54, 0xbd, 0xc5, 0x9d, 0xe3, 0xc4,
+		0x17, 0x5e, 0x5b, 0x8c, 0x16, 0x49, 0x59, 0xa5, 0xa4, 0x44, 0x69, 0x65, 0xa5, 0x45, 0x7c, 0x9a,
+		0x5d, 0xac, 0xef, 0xec, 0xda, 0xdc, 0x6e, 0xf0, 0x2f, 0xf4, 0x38, 0x84, 0x88, 0x42, 0xf0, 0x7b,
+		0x05, 0xd9, 0xa1, 0xa8, 0xc7, 0x49, 0x4b, 0x15, 0x62, 0xa4, 0xe1, 0x0f, 0xfe, 0x97, 0x45, 0x49,
+		0xa1, 0x18, 0xa8, 0x08, 0xb3, 0x6d, 0xcd, 0xb2, 0x55, 0xba, 0x1e, 0x93, 0xe6, 0xd9, 0x85, 0x82,
+		0xe3, 0xc3, 0x02, 0xe1, 0x82, 0xe5, 0xac, 0x27, 0x08, 0x16, 0x2b, 0x6a, 0xa1, 0x53, 0x20, 0x53,
+		0x22, 0x4d, 0x3a, 0x03, 0x99, 0x97, 0x18, 0xa1, 0x72, 0x4f, 0x91, 0x72, 0x36, 0x31, 0xa9, 0xaf,
+		0x78, 0x02, 0xe2, 0xf4, 0x1d, 0x2a, 0x0a, 0xc2, 0x6e, 0x72, 0xc6, 0x48, 0x01, 0xad, 0xbc, 0x0f,
+		0xd2, 0xae, 0xd5, 0x67, 0x20, 0x31, 0x46, 0xc5, 0x2d, 0xa6, 0x80, 0x0f, 0xc3, 0x82, 0x81, 0xf7,
+		0x6c, 0x75, 0x10, 0x3a, 0x4e, 0xa1, 0x11, 0xa9, 0xbb, 0xe6, 0xc7, 0xb8, 0x07, 0x52, 0x4d, 0x21,
+		0x7c, 0x06, 0x0b, 0x14, 0x76, 0xd6, 0x29, 0xa5, 0x60, 0xc7, 0x21, 0xa6, 0x75, 0xbb, 0x0c, 0x20,
+		0xc1, 0xad, 0x7e, 0xb7, 0x4b, 0xab, 0x4e, 0xc3, 0x1c, 0xed, 0x63, 0x0f, 0x5b, 0xfd, 0xb6, 0xcd,
+		0x89, 0x24, 0x29, 0x4c, 0x9a, 0x54, 0x28, 0xac, 0x9c, 0xc2, 0xde, 0x0d, 0xb3, 0xf8, 0xa6, 0xde,
+		0xc2, 0x46, 0x13, 0x33, 0xb8, 0x59, 0x0a, 0x97, 0x14, 0x85, 0x14, 0xe8, 0x7e, 0x70, 0xac, 0xb9,
+		0x2a, 0x56, 0x9a, 0x14, 0xa3, 0x27, 0xca, 0xf3, 0xac, 0x38, 0x97, 0x81, 0x50, 0x49, 0xb3, 0x35,
+		0xe2, 0x2e, 0xd9, 0x7b, 0x6c, 0xf9, 0x4c, 0x2a, 0xe4, 0xcf, 0xdc, 0x2f, 0x05, 0x21, 0x74, 0xcd,
+		0xb4, 0x31, 0x7a, 0xc4, 0xe3, 0xca, 0xa6, 0x46, 0xe9, 0x73, 0x5d, 0xdf, 0x31, 0x70, 0x6b, 0xdd,
+		0xda, 0xf1, 0xbc, 0xfd, 0xea, 0xaa, 0x53, 0xc0, 0xa7, 0x4e, 0x0b, 0x10, 0xee, 0x99, 0x7d, 0xa3,
+		0x25, 0x8e, 0xef, 0xd3, 0x0f, 0x54, 0x86, 0x98, 0xa3, 0x25, 0xa1, 0x49, 0x5a, 0x92, 0x26, 0x5a,
+		0x42, 0x74, 0x98, 0x17, 0x28, 0xd1, 0x2d, 0xae, 0x2c, 0x05, 0x88, 0x3b, 0xc6, 0x8b, 0x6b, 0xdb,
+		0x74, 0x0a, 0xeb, 0xa2, 0x91, 0x25, 0xd2, 0x19, 0x7b, 0x47, 0x78, 0x4c, 0xe3, 0x64, 0xa7, 0x82,
+		0x4b, 0xcf, 0xa7, 0x56, 0xfc, 0x1d, 0xda, 0x28, 0xed, 0x97, 0xab, 0x56, 0xec, 0x2d, 0xda, 0x3b,
+		0x20, 0x6e, 0xe9, 0x3b, 0x06, 0xbd, 0x11, 0xc3, 0x35, 0xcf, 0x2d, 0x20, 0xb5, 0xee, 0x7d, 0x60,
+		0xa6, 0x69, 0x9e, 0xf7, 0xce, 0xcf, 0xc0, 0xbc, 0xfb, 0xd2, 0xb8, 0x4b, 0x85, 0x69, 0x19, 0x72,
+		0xaa, 0xea, 0xa2, 0x26, 0xf7, 0x6b, 0x12, 0x44, 0xf8, 0x8a, 0xe5, 0x0e, 0x83, 0x34, 0x7a, 0x18,
+		0x02, 0xe3, 0x86, 0x21, 0x78, 0xfb, 0xc3, 0x90, 0x07, 0x70, 0xd8, 0xb4, 0xf8, 0x6b, 0xa3, 0x23,
+		0xdc, 0x2a, 0xc6, 0x62, 0x5d, 0xdf, 0xe1, 0xf3, 0xde, 0x83, 0x94, 0xfb, 0x03, 0x89, 0x78, 0xf8,
+		0xbc, 0x1e, 0xe5, 0x61, 0x56, 0xf0, 0xa5, 0x6e, 0xb7, 0xb5, 0x1d, 0xae, 0x8a, 0x77, 0x8e, 0x65,
+		0x8e, 0xac, 0xc2, 0x4a, 0x82, 0xf3, 0x43, 0xfd, 0x89, 0x91, 0xc3, 0x1a, 0x18, 0x33, 0xac, 0x3e,
+		0x3d, 0x0a, 0xde, 0x9e, 0x1e, 0xf9, 0x46, 0x3c, 0x34, 0x30, 0xe2, 0xb9, 0x3f, 0x94, 0xf8, 0x3b,
+		0xe7, 0x2d, 0x76, 0xfd, 0xe7, 0xff, 0xd4, 0x50, 0x3d, 0xc7, 0x75, 0xab, 0x85, 0x5b, 0xea, 0xd0,
+		0x98, 0xdd, 0x3d, 0x4c, 0xd1, 0xcf, 0xb3, 0x3b, 0x76, 0x48, 0x50, 0xa9, 0xbb, 0x63, 0xf8, 0xd9,
+		0x00, 0xcc, 0x0d, 0xc1, 0xff, 0xed, 0x1b, 0x4b, 0xff, 0xec, 0x0d, 0x4f, 0x39, 0x7b, 0x23, 0x63,
+		0x67, 0xef, 0x2f, 0x04, 0x68, 0x02, 0xa0, 0x6b, 0x5a, 0x5a, 0xfb, 0x6f, 0xc2, 0xf6, 0x9e, 0x80,
+		0x78, 0xd7, 0x6c, 0xab, 0xac, 0x86, 0x5d, 0xa0, 0x8a, 0x75, 0xcd, 0xb6, 0x32, 0xa4, 0x66, 0xe1,
+		0xb7, 0xc8, 0x30, 0x47, 0xde, 0x82, 0x41, 0x88, 0x0e, 0x4e, 0xa8, 0x1e, 0x24, 0x99, 0x28, 0xb8,
+		0xd7, 0xf4, 0x30, 0x91, 0x01, 0x75, 0xc3, 0xa4, 0x61, 0x2f, 0x8f, 0xb1, 0xcd, 0x20, 0x15, 0x0e,
+		0x47, 0x30, 0x98, 0x93, 0x31, 0x2a, 0x73, 0xe4, 0xb5, 0x58, 0x0a, 0x87, 0xcb, 0xfd, 0x90, 0x04,
+		0xb0, 0x46, 0x24, 0x4b, 0xfb, 0x4b, 0xfc, 0x1d, 0x8b, 0xb2, 0xa0, 0xfa, 0x5a, 0x3e, 0x39, 0x6e,
+		0xd0, 0x78, 0xfb, 0x49, 0xcb, 0xcb, 0x77, 0x11, 0x66, 0x5d, 0xdd, 0xb6, 0xb0, 0x60, 0xe6, 0xe4,
+		0x01, 0x51, 0x69, 0x1d, 0xdb, 0x4a, 0xf2, 0xa6, 0xe7, 0x2b, 0xf7, 0x2f, 0x25, 0x88, 0x53, 0x9e,
+		0xd6, 0xb1, 0xad, 0xf9, 0xc6, 0x50, 0xba, 0xfd, 0x31, 0xbc, 0x13, 0x80, 0x91, 0xb1, 0xf4, 0x17,
+		0x31, 0xd7, 0xac, 0x38, 0x2d, 0xa9, 0xeb, 0x2f, 0x62, 0x74, 0xde, 0x11, 0x78, 0xf0, 0x60, 0x81,
+		0x8b, 0xa8, 0x95, 0x8b, 0xfd, 0x18, 0x44, 0xe9, 0x3b, 0x12, 0x7b, 0x16, 0x0f, 0x44, 0x23, 0x46,
+		0xbf, 0xd3, 0xd8, 0xb3, 0x72, 0xcf, 0x43, 0xb4, 0xb1, 0xc7, 0xf2, 0x89, 0x27, 0x20, 0xde, 0x33,
+		0x4d, 0xee, 0xfd, 0x31, 0xaf, 0x3b, 0x46, 0x0a, 0xa8, 0xb3, 0x23, 0x72, 0x68, 0x01, 0x37, 0x87,
+		0xe6, 0x26, 0x01, 0x83, 0x53, 0x25, 0x01, 0x49, 0xf4, 0x39, 0xeb, 0x9b, 0x49, 0xe8, 0x41, 0x38,
+		0x56, 0xaf, 0x5c, 0xae, 0x96, 0x4b, 0xea, 0x7a, 0xfd, 0xf2, 0xc0, 0xfd, 0xf9, 0x6c, 0xfa, 0x95,
+		0x5b, 0x4b, 0x09, 0x1e, 0x76, 0x8e, 0x83, 0xde, 0x50, 0xca, 0xd7, 0x6a, 0x8d, 0xb2, 0x2c, 0x31,
+		0xe8, 0x8d, 0x1e, 0xbe, 0x69, 0xda, 0xec, 0x47, 0x70, 0x1e, 0x86, 0xe3, 0x23, 0xa0, 0x9d, 0xe0,
+		0x73, 0xee, 0x95, 0x5b, 0x4b, 0xb3, 0x1b, 0x3d, 0xcc, 0xb4, 0x8c, 0x62, 0x2c, 0x43, 0x66, 0x18,
+		0xa3, 0xb6, 0x51, 0xab, 0xe7, 0xd7, 0xe4, 0xa5, 0xac, 0xfc, 0xca, 0xad, 0xa5, 0xa4, 0x30, 0x19,
+		0x04, 0xfe, 0x9b, 0x1f, 0x7d, 0x7e, 0x6f, 0xcc, 0x97, 0x35, 0x66, 0x71, 0x5d, 0x57, 0xeb, 0x69,
+		0x9d, 0xc3, 0x86, 0x9f, 0x13, 0x0e, 0x23, 0xe4, 0x3e, 0x13, 0x80, 0xb4, 0x13, 0xdc, 0x6c, 0xd0,
+		0x16, 0xd0, 0x23, 0xde, 0x8c, 0x5f, 0x62, 0xec, 0xda, 0xc1, 0xa0, 0x45, 0x42, 0xf0, 0x9d, 0x10,
+		0x13, 0x4e, 0x32, 0x9f, 0x54, 0x4b, 0x23, 0xd6, 0x37, 0x0e, 0xc1, 0x51, 0x1d, 0x0c, 0xf4, 0x24,
+		0xc4, 0x9d, 0x29, 0xe6, 0xbc, 0x1e, 0x3e, 0x7e, 0x4e, 0x72, 0x7c, 0x17, 0x07, 0x5d, 0x70, 0xc3,
+		0xb8, 0xd0, 0xb8, 0xc0, 0xf0, 0x1a, 0x03, 0xe0, 0xc8, 0x4e, 0x08, 0xf7, 0x30, 0x84, 0xb4, 0xad,
+		0xa6, 0xce, 0x0d, 0xf0, 0x1d, 0xc3, 0x78, 0xf9, 0x42, 0xb1, 0xc2, 0x91, 0x28, 0x64, 0xae, 0xc2,
+		0x93, 0x29, 0x5c, 0x5e, 0xf4, 0x3d, 0xd6, 0x3d, 0x95, 0xc5, 0xc2, 0xcc, 0xbb, 0x88, 0x75, 0xb4,
+		0xbd, 0x02, 0x0d, 0x87, 0x8f, 0x41, 0x94, 0x54, 0xee, 0xf0, 0x87, 0xd1, 0x82, 0x4a, 0xa4, 0xa3,
+		0xed, 0x5d, 0xd6, 0xac, 0xab, 0xa1, 0x58, 0x50, 0x0e, 0xe5, 0x7e, 0x8a, 0x78, 0x2a, 0x3e, 0xa9,
+		0xa0, 0x07, 0x00, 0x11, 0x0c, 0x6d, 0x07, 0xab, 0x64, 0xea, 0x52, 0xf1, 0x0a, 0xba, 0xe9, 0x8e,
+		0xb6, 0x97, 0xdf, 0xc1, 0xd5, 0x7e, 0x87, 0x32, 0x60, 0xa1, 0x75, 0x90, 0x05, 0xb0, 0x18, 0x59,
+		0x2e, 0xfe, 0xe3, 0xc3, 0x3f, 0x27, 0xc3, 0x01, 0xd8, 0x02, 0xf0, 0x2a, 0x59, 0x00, 0x52, 0x8c,
+		0x9e, 0x73, 0xfc, 0xc4, 0xd7, 0x95, 0xa0, 0xbf, 0x2b, 0xb9, 0x27, 0x21, 0x3d, 0x30, 0x02, 0x28,
+		0x07, 0xb3, 0x3c, 0x63, 0x45, 0xb7, 0xf6, 0x59, 0x84, 0x13, 0x57, 0x12, 0x2c, 0x33, 0x45, 0x8f,
+		0x3a, 0xac, 0xc6, 0x7e, 0xf9, 0xa3, 0x8b, 0x12, 0xdd, 0xf6, 0x79, 0x00, 0x66, 0x7d, 0x63, 0x20,
+		0xb2, 0xc8, 0x92, 0x9b, 0x45, 0x76, 0x81, 0x9f, 0x83, 0x24, 0x31, 0x40, 0xb8, 0xc5, 0x61, 0xef,
+		0x85, 0x34, 0x33, 0x90, 0x83, 0xb2, 0x66, 0x0e, 0xcf, 0xba, 0x10, 0x78, 0x4e, 0x78, 0x40, 0x7e,
+		0xb1, 0x27, 0x04, 0xd4, 0x65, 0xcd, 0xca, 0xd5, 0x00, 0xdc, 0x41, 0x45, 0x79, 0xb8, 0x93, 0x18,
+		0x0f, 0xef, 0x51, 0x54, 0xfe, 0xe0, 0xb4, 0xcf, 0x63, 0xcc, 0x12, 0x20, 0xf7, 0xb8, 0x29, 0x7b,
+		0x76, 0xfa, 0x0a, 0x85, 0x28, 0x3c, 0xfd, 0xa9, 0x2f, 0x9c, 0x94, 0xbe, 0x39, 0xb6, 0xe0, 0xf7,
+		0xaf, 0xc3, 0x09, 0x4f, 0x25, 0x51, 0x40, 0x5f, 0x22, 0x2a, 0xed, 0xd1, 0x57, 0x52, 0x39, 0x29,
+		0xa1, 0x74, 0x60, 0xfe, 0x37, 0x7b, 0xb0, 0xd9, 0x99, 0x9c, 0x6d, 0x9a, 0x9c, 0xef, 0x1a, 0x9d,
+		0x94, 0xff, 0x17, 0x71, 0x88, 0x2a, 0xf8, 0x3d, 0x7d, 0x6c, 0xd9, 0x68, 0x05, 0x42, 0xb8, 0xb9,
+		0x6b, 0x8e, 0xca, 0x81, 0x92, 0x0e, 0x2e, 0x73, 0xb8, 0x72, 0x73, 0xd7, 0xbc, 0x32, 0xa3, 0x50,
+		0x58, 0x74, 0x0e, 0xc2, 0xdb, 0xed, 0x3e, 0x4f, 0x5f, 0x0d, 0xd8, 0x2c, 0x2f, 0xd2, 0x25, 0x02,
+		0x74, 0x65, 0x46, 0x61, 0xd0, 0xa4, 0x29, 0xfa, 0x0b, 0x61, 0xc1, 0x83, 0x9b, 0xaa, 0x18, 0xdb,
+		0xb4, 0x29, 0x02, 0x8b, 0x0a, 0x00, 0xba, 0xa1, 0xdb, 0x2a, 0x4d, 0xed, 0x70, 0xab, 0x71, 0xd7,
+		0x78, 0x4c, 0xdd, 0xa6, 0xc9, 0xa0, 0x2b, 0x33, 0x4a, 0x5c, 0x17, 0x1f, 0x84, 0xdd, 0xf7, 0xf4,
+		0x71, 0x6f, 0x9f, 0x7b, 0x6b, 0x63, 0xd9, 0x7d, 0x9a, 0x00, 0x11, 0x76, 0x29, 0x34, 0x31, 0xb2,
+		0xec, 0x05, 0x7a, 0x7b, 0x8f, 0xff, 0xae, 0xca, 0xe2, 0x38, 0x4c, 0xfa, 0x0c, 0x7d, 0x63, 0xef,
+		0xca, 0x8c, 0x12, 0x6d, 0xb2, 0x3f, 0xd1, 0xe3, 0x8e, 0x0b, 0x96, 0x18, 0xf6, 0x7a, 0x7c, 0xb8,
+		0x2c, 0xed, 0x33, 0x23, 0x5c, 0x31, 0x54, 0x85, 0x54, 0x5b, 0xb7, 0x6c, 0xd5, 0x32, 0xb4, 0xae,
+		0xb5, 0x6b, 0xda, 0xe2, 0x09, 0xe8, 0x7b, 0xc6, 0x51, 0x58, 0xd3, 0x2d, 0xbb, 0x2e, 0x80, 0xaf,
+		0xcc, 0x28, 0xb3, 0x6d, 0x6f, 0x01, 0xa1, 0x67, 0x6e, 0x6f, 0xe3, 0x9e, 0x43, 0x90, 0xe6, 0x59,
+		0x0e, 0xa0, 0x57, 0x23, 0xd0, 0x02, 0x9f, 0xd0, 0x33, 0xbd, 0x05, 0xe8, 0x5b, 0x60, 0xbe, 0x6d,
+		0x6a, 0x2d, 0x87, 0x9c, 0xda, 0xdc, 0xed, 0x1b, 0x37, 0x68, 0x52, 0x26, 0xb1, 0x72, 0xff, 0x58,
+		0x26, 0x4d, 0xad, 0x25, 0x48, 0x14, 0x09, 0xc2, 0x95, 0x19, 0x65, 0xae, 0x3d, 0x58, 0x88, 0xde,
+		0x0d, 0x0b, 0x5a, 0xb7, 0xdb, 0xde, 0x1f, 0xa4, 0x9e, 0xa6, 0xd4, 0x4f, 0x8f, 0xa3, 0x9e, 0x27,
+		0x38, 0x83, 0xe4, 0x91, 0x36, 0x54, 0x8a, 0x1a, 0x20, 0x77, 0x7b, 0x98, 0xde, 0xe6, 0xea, 0x72,
+		0x2f, 0x83, 0xbe, 0xaf, 0x9c, 0x58, 0xb9, 0x6f, 0x1c, 0xed, 0x0d, 0x06, 0x2f, 0x9c, 0x92, 0x2b,
+		0x33, 0x4a, 0xba, 0xeb, 0x2f, 0x62, 0x54, 0xcd, 0x26, 0xa6, 0x8f, 0xd1, 0x73, 0xaa, 0x73, 0x93,
+		0xa8, 0x52, 0x78, 0x3f, 0x55, 0x5f, 0x11, 0x2a, 0x43, 0x82, 0x85, 0xa2, 0x2a, 0x31, 0x86, 0xf4,
+		0x91, 0xff, 0xc4, 0x4a, 0x6e, 0xec, 0x0c, 0xa5, 0xa0, 0xd7, 0x4c, 0x1b, 0x5f, 0x99, 0x51, 0x00,
+		0x3b, 0x5f, 0x48, 0x83, 0x23, 0xf4, 0x81, 0xea, 0x7d, 0xd5, 0x6f, 0x78, 0x33, 0xf3, 0x94, 0xe0,
+		0x03, 0xe3, 0x08, 0xd2, 0x1f, 0x7e, 0xda, 0xbf, 0xe6, 0xb5, 0xc3, 0x57, 0x66, 0x94, 0xf9, 0x9b,
+		0xc3, 0xc5, 0x44, 0xc5, 0xb6, 0x75, 0x43, 0x6b, 0xeb, 0x2f, 0x62, 0xb6, 0x84, 0xd2, 0xdf, 0x7b,
+		0x38, 0x40, 0xc5, 0x2e, 0x71, 0x68, 0xba, 0xb0, 0x12, 0x15, 0xdb, 0xf6, 0x16, 0x14, 0xa2, 0xfc,
+		0x1c, 0xaa, 0xf3, 0x70, 0x6b, 0x54, 0x8e, 0xb1, 0xe7, 0xc5, 0xaf, 0x86, 0x62, 0x20, 0x27, 0x72,
+		0xf7, 0x41, 0xc2, 0x63, 0x98, 0x50, 0x06, 0xa2, 0xfc, 0xa4, 0x8e, 0x38, 0xd1, 0xca, 0x3f, 0x73,
+		0x29, 0x48, 0x7a, 0x8d, 0x51, 0xee, 0x83, 0x92, 0x83, 0x49, 0x5f, 0x06, 0xc9, 0xf8, 0x33, 0xd2,
+		0x71, 0xd7, 0x53, 0xb9, 0x5b, 0x2c, 0x6d, 0xa2, 0x9e, 0x6d, 0xbf, 0x26, 0x69, 0x21, 0x5f, 0x59,
+		0xd1, 0x22, 0x24, 0xba, 0x2b, 0x5d, 0x07, 0x24, 0x48, 0x41, 0xa0, 0xbb, 0xd2, 0x15, 0x00, 0x77,
+		0x41, 0x92, 0xf4, 0x5b, 0xf5, 0xfa, 0x4b, 0x71, 0x25, 0x41, 0xca, 0x38, 0x48, 0xee, 0xb7, 0x02,
+		0x20, 0x0f, 0x1a, 0x30, 0x27, 0x55, 0x2d, 0x1d, 0x3a, 0x55, 0x7d, 0x7c, 0x30, 0x49, 0xee, 0xe6,
+		0xc5, 0xd7, 0x40, 0x76, 0xd3, 0xbb, 0x6c, 0xa9, 0x19, 0xef, 0xff, 0x0d, 0x38, 0xaa, 0x4a, 0xba,
+		0x39, 0xe0, 0xb9, 0x5e, 0xf2, 0x6d, 0x56, 0x8a, 0x9f, 0xd0, 0x1c, 0x1c, 0x70, 0xc7, 0x89, 0xd9,
+		0xec, 0xb6, 0x34, 0x1b, 0x8b, 0xfc, 0x98, 0x67, 0xdf, 0xf2, 0x5e, 0x48, 0x6b, 0xdd, 0xae, 0x6a,
+		0xd9, 0x9a, 0x8d, 0xb9, 0xaf, 0xc1, 0x32, 0x0f, 0xb3, 0x5a, 0xb7, 0x4b, 0x7f, 0x71, 0x8c, 0xf9,
+		0x1a, 0xf7, 0x40, 0x8a, 0xd8, 0x74, 0x5d, 0x6b, 0x0b, 0x57, 0x21, 0xc2, 0x5c, 0x12, 0x5e, 0xca,
+		0xbc, 0x83, 0x5c, 0xcb, 0x19, 0x71, 0x6a, 0xcf, 0x9d, 0x98, 0x4a, 0xf2, 0xc4, 0x54, 0x88, 0xbf,
+		0xd8, 0xc2, 0xe4, 0x23, 0x1e, 0xd7, 0x19, 0xbd, 0x69, 0xb0, 0x40, 0xe3, 0xaf, 0x9b, 0x2c, 0x59,
+		0x12, 0x53, 0xd8, 0x47, 0x4e, 0x81, 0x94, 0xdf, 0xf6, 0xa3, 0x14, 0x04, 0xec, 0x3d, 0xde, 0x4a,
+		0xc0, 0xde, 0x23, 0x9e, 0xae, 0xe7, 0x41, 0xc1, 0xe1, 0xd5, 0x8e, 0xe3, 0xb9, 0xb9, 0x8e, 0x5c,
+		0x1a, 0x66, 0x7d, 0x6b, 0x42, 0xee, 0x28, 0x2c, 0x8c, 0x32, 0xf1, 0xb9, 0x5d, 0xa7, 0xdc, 0x67,
+		0xaa, 0xd1, 0x39, 0x88, 0x39, 0x36, 0x7e, 0x44, 0x74, 0x4c, 0x9b, 0x15, 0xc0, 0x8a, 0x03, 0xea,
+		0x4b, 0xe7, 0x07, 0x7c, 0xe9, 0xfc, 0xdc, 0xb7, 0x43, 0x66, 0x9c, 0xfd, 0x1e, 0x48, 0xf2, 0x85,
+		0x1c, 0x81, 0x1d, 0x85, 0x08, 0x7f, 0x3f, 0x2f, 0x40, 0x37, 0xb0, 0xf8, 0x17, 0x11, 0x24, 0xb3,
+		0xe5, 0x41, 0xb6, 0xaf, 0x45, 0x3f, 0x72, 0x2a, 0x1c, 0x1f, 0x6b, 0xc3, 0xc7, 0x6f, 0x85, 0x31,
+		0x42, 0x7c, 0x2b, 0xac, 0x29, 0xd8, 0xb1, 0x68, 0x5f, 0xc5, 0x41, 0x16, 0xf6, 0x95, 0x7b, 0x35,
+		0x08, 0x47, 0x47, 0x5b, 0x72, 0xb4, 0x04, 0x49, 0xe2, 0xb7, 0xda, 0x7e, 0x17, 0x17, 0x3a, 0xda,
+		0x5e, 0x83, 0xfb, 0xb7, 0x7c, 0x2b, 0x21, 0xe0, 0x6c, 0x25, 0xa0, 0x4d, 0x98, 0x6b, 0x9b, 0x4d,
+		0xad, 0xad, 0x7a, 0xb6, 0x72, 0xf8, 0x24, 0xba, 0x7b, 0x48, 0xd8, 0xfe, 0x94, 0x21, 0x31, 0x38,
+		0x5c, 0xff, 0xd3, 0x94, 0xc6, 0x9a, 0xb3, 0xeb, 0x83, 0x4a, 0x90, 0xe8, 0xe8, 0xd6, 0x16, 0xde,
+		0xd5, 0x6e, 0xea, 0x66, 0x8f, 0xcf, 0xa6, 0x61, 0xa5, 0x59, 0x77, 0x61, 0xc4, 0x0e, 0x93, 0x07,
+		0xcd, 0x33, 0x24, 0xe1, 0x91, 0x1b, 0x5f, 0x91, 0x43, 0x5b, 0x93, 0x71, 0x7b, 0x48, 0xd1, 0xb1,
+		0x7b, 0x48, 0xa3, 0x36, 0x6c, 0x62, 0xa3, 0x37, 0x6c, 0x5e, 0xf6, 0x0e, 0x8d, 0x7f, 0xed, 0x1b,
+		0xda, 0xc3, 0x41, 0x75, 0x58, 0xe0, 0xf8, 0x2d, 0x9f, 0xec, 0x47, 0x1c, 0x75, 0x60, 0xf3, 0x6b,
+		0x50, 0xe6, 0x48, 0xa0, 0x8f, 0x17, 0x7b, 0xf0, 0xf6, 0xc4, 0x2e, 0x36, 0x51, 0x43, 0x9e, 0x4d,
+		0xd4, 0xff, 0xcb, 0x86, 0xe2, 0xbd, 0x41, 0x98, 0x1b, 0x72, 0x24, 0x46, 0xee, 0x0e, 0x8f, 0xcb,
+		0xc8, 0x8a, 0x8e, 0x05, 0x0f, 0xdd, 0x31, 0x3e, 0xd6, 0xa1, 0xc9, 0x63, 0x1d, 0x7e, 0x0b, 0xc7,
+		0x3a, 0x72, 0x7b, 0x63, 0xfd, 0x4d, 0x1d, 0x85, 0x1f, 0x93, 0x20, 0x3b, 0xde, 0xfb, 0x1a, 0x39,
+		0x1c, 0x87, 0xda, 0x40, 0x18, 0xb7, 0xc6, 0xdd, 0x03, 0xa9, 0x01, 0xdf, 0x90, 0xa9, 0xf2, 0xac,
+		0x2f, 0x0a, 0xcf, 0xbd, 0x2f, 0xe8, 0x2c, 0x3c, 0x3e, 0x07, 0x6e, 0xc4, 0x6c, 0x7d, 0x1a, 0xe6,
+		0x5b, 0xb8, 0xa9, 0xb7, 0x6e, 0x77, 0xb2, 0xce, 0x71, 0xec, 0xff, 0x37, 0x57, 0x87, 0xb5, 0xe4,
+		0x07, 0x01, 0x62, 0x0a, 0xb6, 0xba, 0xc4, 0x1f, 0x43, 0x05, 0x88, 0xe3, 0xbd, 0x26, 0xee, 0xda,
+		0xee, 0xa1, 0x8a, 0x51, 0x21, 0x02, 0x83, 0x2e, 0x0b, 0x48, 0x12, 0x20, 0x3b, 0x68, 0xe8, 0x11,
+		0x9e, 0x03, 0x18, 0x1f, 0xce, 0x73, 0x74, 0x6f, 0x12, 0xe0, 0xbc, 0x48, 0x02, 0x04, 0xc7, 0xc6,
+		0xb7, 0x0c, 0x6b, 0x20, 0x0b, 0xf0, 0x08, 0xcf, 0x02, 0x84, 0x26, 0x34, 0xe6, 0x4b, 0x03, 0x14,
+		0x7d, 0x69, 0x80, 0xc8, 0x84, 0x6e, 0x8e, 0xc9, 0x03, 0x9c, 0x17, 0x79, 0x80, 0xe8, 0x04, 0x8e,
+		0x07, 0x12, 0x01, 0x4f, 0x78, 0x12, 0x01, 0xf1, 0xe1, 0x6c, 0xab, 0x0f, 0x75, 0x44, 0x26, 0xe0,
+		0x82, 0x93, 0x09, 0x48, 0x8e, 0xcd, 0x22, 0x70, 0xe4, 0xc1, 0x54, 0x40, 0x6d, 0x28, 0x15, 0x30,
+		0xcb, 0x7f, 0x0e, 0x7a, 0x1c, 0x89, 0x09, 0xb9, 0x80, 0xda, 0x50, 0x2e, 0x20, 0x35, 0x81, 0xe0,
+		0x84, 0x64, 0xc0, 0xb7, 0x8e, 0x4e, 0x06, 0x8c, 0x0f, 0xd7, 0x39, 0x9b, 0xd3, 0x65, 0x03, 0xd4,
+		0x31, 0xd9, 0x00, 0x79, 0x6c, 0xe4, 0xca, 0xc8, 0x4f, 0x9d, 0x0e, 0xd8, 0x1c, 0x91, 0x0e, 0x60,
+		0x81, 0xfb, 0xa9, 0xb1, 0xc4, 0xa7, 0xc8, 0x07, 0x6c, 0x8e, 0xc8, 0x07, 0xa0, 0x89, 0x64, 0x27,
+		0x26, 0x04, 0x2e, 0xf9, 0x13, 0x02, 0xf3, 0x63, 0xbc, 0x4e, 0x77, 0xb6, 0x8f, 0xc9, 0x08, 0x6c,
+		0x8d, 0xcb, 0x08, 0x2c, 0xf0, 0x9f, 0x99, 0x18, 0x47, 0xf1, 0x10, 0x29, 0x81, 0xda, 0x50, 0x4a,
+		0xe0, 0xc8, 0x04, 0x4d, 0x9b, 0x3e, 0x27, 0xc0, 0x7e, 0x78, 0x8c, 0xfd, 0xe4, 0x18, 0xc8, 0x89,
+		0xab, 0xa1, 0x58, 0x42, 0x4e, 0xe6, 0xee, 0x27, 0x1e, 0xcc, 0x80, 0x9d, 0x23, 0xb1, 0x02, 0xee,
+		0xf5, 0xcc, 0x9e, 0xb8, 0x63, 0x41, 0x3f, 0x72, 0xa7, 0x48, 0x8c, 0xe8, 0xda, 0xb4, 0x03, 0xf2,
+		0x07, 0x34, 0x26, 0xf3, 0xd8, 0xb1, 0xdc, 0x2f, 0x4b, 0x2e, 0x2e, 0xcd, 0x20, 0x78, 0xe3, 0xcb,
+		0x38, 0x8f, 0x2f, 0x3d, 0x59, 0x85, 0x80, 0x3f, 0xab, 0xb0, 0x08, 0x09, 0x12, 0x6b, 0x0d, 0x24,
+		0x0c, 0xb4, 0xae, 0x93, 0x30, 0x10, 0x07, 0xa8, 0x58, 0xee, 0x81, 0x2f, 0x4b, 0x6c, 0x37, 0x31,
+		0xed, 0x1c, 0x26, 0x63, 0xa1, 0x2e, 0x7a, 0x08, 0xe6, 0x3d, 0xb0, 0x4e, 0x0c, 0xc7, 0xa2, 0x67,
+		0xd9, 0x81, 0xce, 0xf3, 0x60, 0xee, 0x5f, 0x4b, 0xae, 0x84, 0xdc, 0x4c, 0xc3, 0xa8, 0xa4, 0x80,
+		0xf4, 0x16, 0x25, 0x05, 0x02, 0xb7, 0x9d, 0x14, 0xf0, 0xc6, 0xa4, 0x41, 0x7f, 0x4c, 0xfa, 0x3f,
+		0x24, 0x77, 0x4c, 0x9c, 0x10, 0xbf, 0x69, 0xb6, 0x30, 0x8f, 0x12, 0xe9, 0xdf, 0xc4, 0x25, 0x69,
+		0x9b, 0xe2, 0xf7, 0xa2, 0xc8, 0x9f, 0x04, 0xca, 0x59, 0x78, 0xe2, 0x7c, 0x5d, 0x71, 0x02, 0xcc,
+		0xb0, 0xf7, 0x1e, 0x07, 0xbf, 0xdc, 0x10, 0x71, 0x2f, 0x37, 0x38, 0x17, 0xa3, 0xa3, 0x9e, 0x8b,
+		0xd1, 0xe8, 0x71, 0x88, 0xd3, 0x64, 0xbf, 0x6a, 0x76, 0xc5, 0x4f, 0x6f, 0x9f, 0x18, 0x7f, 0xb1,
+		0xc1, 0xa2, 0x47, 0xae, 0xd9, 0x65, 0x08, 0xd7, 0xe3, 0x88, 0xfb, 0x3c, 0x8e, 0x3b, 0x20, 0x4e,
+		0xb8, 0x67, 0xbf, 0x3d, 0x09, 0xfc, 0x56, 0xbd, 0x28, 0xc8, 0xfd, 0x74, 0x00, 0xd2, 0x03, 0x0b,
+		0xcd, 0xc8, 0xbe, 0x8f, 0xda, 0x46, 0x9e, 0x4e, 0x1e, 0x27, 0x01, 0x76, 0x34, 0x4b, 0x7d, 0x41,
+		0x33, 0x6c, 0xfe, 0x7b, 0xf1, 0x41, 0xc5, 0x53, 0x82, 0xb2, 0x10, 0x23, 0x5f, 0x7d, 0x8b, 0xff,
+		0x62, 0x7c, 0x50, 0x71, 0xbe, 0xd1, 0x15, 0x88, 0xe0, 0x9b, 0xf4, 0x69, 0x60, 0xf6, 0x73, 0x21,
+		0x47, 0x87, 0xc3, 0x61, 0x52, 0x5d, 0xc8, 0x90, 0xc1, 0xfe, 0xf2, 0x6b, 0x8b, 0x32, 0x83, 0x7e,
+		0xd0, 0xb9, 0xcc, 0xa6, 0x70, 0x7c, 0xbf, 0x14, 0x62, 0x03, 0x52, 0xa0, 0x79, 0xc0, 0xa4, 0x08,
+		0xef, 0x89, 0x4c, 0xd9, 0x19, 0x6f, 0x65, 0xb6, 0x83, 0x3b, 0x5d, 0xd3, 0x6c, 0xab, 0x6c, 0x8e,
+		0xe7, 0x21, 0xe5, 0x5f, 0x57, 0xd9, 0xcf, 0x3b, 0xdb, 0x9a, 0x6e, 0xa8, 0x3e, 0x27, 0x38, 0xc9,
+		0x0a, 0xd9, 0x9c, 0xf2, 0xbe, 0xfb, 0x9c, 0xdb, 0x80, 0x23, 0x23, 0xd7, 0x55, 0xf4, 0x18, 0xc4,
+		0xdd, 0x25, 0x99, 0x1d, 0xd3, 0x3f, 0x20, 0xd3, 0xe2, 0xc2, 0xe6, 0x7e, 0x55, 0x72, 0x49, 0xfa,
+		0x73, 0x37, 0x65, 0x88, 0xb0, 0x33, 0x93, 0xfc, 0x7c, 0xcc, 0x43, 0xd3, 0xad, 0xc8, 0xcb, 0xec,
+		0x40, 0xa5, 0xc2, 0x91, 0x73, 0xef, 0x86, 0x08, 0x2b, 0x41, 0x09, 0x88, 0xfa, 0x1e, 0xa2, 0xcf,
+		0x17, 0x8b, 0xe5, 0x0d, 0xf1, 0xb4, 0x6f, 0x81, 0x3e, 0xf2, 0x4e, 0x8a, 0x95, 0xf2, 0xd5, 0x72,
+		0xb1, 0x21, 0x07, 0xd1, 0x1c, 0xcc, 0xb2, 0xbf, 0xf9, 0x73, 0xf1, 0x72, 0xc8, 0x53, 0x54, 0x2f,
+		0x57, 0x4b, 0x65, 0x45, 0x0e, 0xe7, 0xce, 0xc2, 0xf1, 0xb1, 0x6b, 0xb8, 0x9b, 0x98, 0x91, 0x3c,
+		0x89, 0x99, 0xdc, 0xab, 0x01, 0x12, 0xd4, 0x8c, 0x5b, 0x98, 0xd1, 0xd5, 0x81, 0x8e, 0xaf, 0x1c,
+		0x62, 0x55, 0x1f, 0xe8, 0x3d, 0x89, 0x63, 0x7a, 0x78, 0x1b, 0xdb, 0xcd, 0x5d, 0xe6, 0x28, 0x30,
+		0x0b, 0x34, 0xab, 0xcc, 0xf2, 0x52, 0x8a, 0x64, 0x31, 0xb0, 0xe7, 0x71, 0xd3, 0x56, 0x99, 0x12,
+		0x59, 0x34, 0x98, 0x88, 0x13, 0x30, 0x52, 0x5a, 0x67, 0x85, 0xb9, 0x6f, 0x3f, 0x94, 0x2c, 0xe3,
+		0x10, 0x56, 0xca, 0x0d, 0xe5, 0x3a, 0xfb, 0x11, 0x77, 0xfa, 0xa7, 0x5a, 0xaf, 0xe6, 0x37, 0xea,
+		0x57, 0x6a, 0x44, 0x96, 0xf3, 0x90, 0x16, 0xb2, 0x14, 0x85, 0xe1, 0xdc, 0x03, 0x70, 0x6c, 0x8c,
+		0x57, 0x31, 0xe2, 0x10, 0xeb, 0xc7, 0x24, 0x2f, 0xb4, 0xdf, 0x33, 0xa8, 0x41, 0xc4, 0xb2, 0x35,
+		0xbb, 0x6f, 0x71, 0x21, 0x3e, 0x36, 0xad, 0x9b, 0xb1, 0x2c, 0xfe, 0xa8, 0x53, 0x74, 0x85, 0x93,
+		0xc9, 0x9d, 0x83, 0x94, 0xbf, 0x66, 0xbc, 0x0c, 0x5c, 0x25, 0x0a, 0xe4, 0x2e, 0x02, 0x1a, 0xf6,
+		0x3e, 0x46, 0x84, 0x97, 0xd2, 0xa8, 0xf0, 0xf2, 0x27, 0x24, 0x38, 0x71, 0x80, 0xa7, 0x81, 0x9e,
+		0x1e, 0xe8, 0xe4, 0x85, 0xc3, 0xf8, 0x29, 0xcb, 0xac, 0x6c, 0xa0, 0x9b, 0x8f, 0x40, 0xd2, 0x5b,
+		0x3e, 0x5d, 0x27, 0xbf, 0x1c, 0x70, 0x27, 0xb1, 0x3f, 0x0e, 0x76, 0x4d, 0xa0, 0xf4, 0x0d, 0x9a,
+		0xc0, 0x77, 0x02, 0xd8, 0x7b, 0xe2, 0x14, 0x35, 0x5f, 0x47, 0xef, 0x1c, 0x91, 0x5f, 0xc4, 0xcd,
+		0xc6, 0x1e, 0x9f, 0x04, 0x71, 0x9b, 0xff, 0x65, 0xa1, 0xba, 0x37, 0x29, 0xd0, 0xa7, 0x6b, 0xac,
+		0xc5, 0x03, 0xe6, 0x69, 0x17, 0x63, 0x37, 0x79, 0xc0, 0x8a, 0x2d, 0x74, 0x1d, 0x8e, 0x0d, 0x38,
+		0x0a, 0x0e, 0xe9, 0xd0, 0xb4, 0xfe, 0xc2, 0x11, 0xbf, 0xbf, 0x20, 0x48, 0x7b, 0x57, 0xfb, 0xb0,
+		0x7f, 0xb5, 0xbf, 0x0e, 0xe0, 0x26, 0x07, 0xdc, 0x63, 0x7f, 0x92, 0xf7, 0xd8, 0xdf, 0x39, 0x08,
+		0x13, 0x4d, 0x12, 0x72, 0x1a, 0x36, 0xc5, 0x44, 0x13, 0x3c, 0xc9, 0x05, 0x06, 0x9d, 0xd3, 0x01,
+		0x0d, 0x27, 0x68, 0xc7, 0x34, 0xf1, 0x84, 0xbf, 0x89, 0xbb, 0xc6, 0xa6, 0x7a, 0x47, 0x37, 0xf5,
+		0x22, 0x84, 0xe9, 0xc8, 0x8f, 0xbc, 0x4b, 0xf9, 0x6d, 0x00, 0x9a, 0x6d, 0xf7, 0xf4, 0xad, 0xbe,
+		0xdb, 0xc0, 0xe2, 0x68, 0xcd, 0xc9, 0x0b, 0xb8, 0xc2, 0x1d, 0x5c, 0x85, 0x16, 0x5c, 0x54, 0x8f,
+		0x1a, 0x79, 0x08, 0xe6, 0xaa, 0x90, 0xf2, 0xe3, 0x8e, 0xbe, 0x1b, 0x3a, 0xfc, 0x43, 0xa1, 0xae,
+		0x77, 0xc4, 0x1f, 0x63, 0xa2, 0x1f, 0xb9, 0x97, 0x02, 0x90, 0xf4, 0x2a, 0xde, 0xdf, 0x3d, 0x17,
+		0x24, 0xf7, 0xdd, 0x12, 0xc4, 0x9c, 0xee, 0x1f, 0x70, 0xd8, 0xd9, 0xbd, 0x23, 0xec, 0x6c, 0x5e,
+		0xb0, 0x6d, 0xa2, 0xa0, 0xb3, 0x4d, 0x74, 0xd1, 0x59, 0xfe, 0xc6, 0x25, 0x44, 0xbc, 0xb2, 0x16,
+		0x07, 0x0e, 0xf9, 0x6a, 0x7f, 0x71, 0xba, 0xab, 0x78, 0x0b, 0x10, 0xf6, 0x5e, 0xa3, 0x63, 0x1f,
+		0xb9, 0x96, 0xe7, 0x84, 0x11, 0x9b, 0x88, 0xde, 0x3b, 0x7b, 0xd2, 0xa1, 0xef, 0xec, 0x39, 0xad,
+		0x04, 0xbc, 0xad, 0x7c, 0x48, 0x82, 0x98, 0x98, 0x13, 0xe8, 0x5d, 0xde, 0x93, 0x67, 0x62, 0x6b,
+		0x73, 0xac, 0x3d, 0xe2, 0xf4, 0x3d, 0x07, 0xcf, 0x86, 0x0e, 0x5c, 0x07, 0x0f, 0x7b, 0xe0, 0x9a,
+		0x7b, 0x76, 0x7f, 0x29, 0x81, 0x3c, 0x38, 0x63, 0xbf, 0x61, 0xee, 0x86, 0x97, 0xb9, 0xe0, 0x88,
+		0x65, 0x6e, 0xdc, 0x29, 0xea, 0xd0, 0xb8, 0x53, 0xd4, 0xc3, 0xbd, 0x0e, 0xdf, 0x66, 0xaf, 0xdf,
+		0x1b, 0x80, 0x84, 0x27, 0x3d, 0x8a, 0x1e, 0xf5, 0x9d, 0xc8, 0x5e, 0x3a, 0x28, 0x95, 0xea, 0x39,
+		0x92, 0xed, 0x13, 0x53, 0xe0, 0xf0, 0x62, 0x7a, 0xeb, 0x6f, 0x67, 0x8d, 0xbe, 0xc0, 0x1a, 0x1e,
+		0x73, 0x81, 0xf5, 0xbb, 0x24, 0x88, 0x39, 0x6e, 0xf7, 0x61, 0x37, 0x31, 0x8f, 0x42, 0x84, 0x7b,
+		0x96, 0x6c, 0x17, 0x93, 0x7f, 0x8d, 0x4c, 0x2b, 0x67, 0x21, 0xd6, 0xc1, 0xb6, 0x46, 0xed, 0x20,
+		0x5b, 0xd5, 0x9c, 0xef, 0xd3, 0x17, 0x20, 0xe1, 0xd9, 0x00, 0x26, 0xa6, 0xb1, 0x5a, 0x7e, 0x46,
+		0x9e, 0xc9, 0x46, 0x5f, 0xb9, 0xb5, 0x14, 0xac, 0xe2, 0x17, 0xc8, 0x6c, 0x56, 0xca, 0xc5, 0x2b,
+		0xe5, 0xe2, 0x53, 0xb2, 0x94, 0x4d, 0xbc, 0x72, 0x6b, 0x29, 0xaa, 0x60, 0x9a, 0x51, 0x3c, 0xfd,
+		0x14, 0xa4, 0x07, 0x06, 0xc6, 0xef, 0xb6, 0x20, 0x48, 0x95, 0x36, 0x37, 0xd6, 0x2a, 0xc5, 0x7c,
+		0xa3, 0xac, 0xb2, 0x73, 0xbb, 0xe8, 0x18, 0xcc, 0xaf, 0x55, 0x2e, 0x5f, 0x69, 0xa8, 0xc5, 0xb5,
+		0x4a, 0xb9, 0xda, 0x50, 0xf3, 0x8d, 0x46, 0xbe, 0xf8, 0x94, 0x1c, 0x58, 0xb9, 0x95, 0x80, 0x50,
+		0xbe, 0x50, 0xac, 0xa0, 0x22, 0x84, 0x68, 0x2a, 0xe4, 0xc0, 0x13, 0x60, 0xd9, 0x83, 0x73, 0xc3,
+		0xe8, 0x12, 0x84, 0x69, 0x96, 0x04, 0x1d, 0x7c, 0x24, 0x2c, 0x3b, 0x21, 0x59, 0x4c, 0x98, 0xa1,
+		0x33, 0xf2, 0xc0, 0x33, 0x62, 0xd9, 0x83, 0x73, 0xc7, 0x68, 0x0d, 0xa2, 0x22, 0x48, 0x9e, 0x74,
+		0x70, 0x2b, 0x3b, 0x31, 0xa1, 0x4b, 0xba, 0xc6, 0x92, 0x0d, 0x07, 0x1f, 0x1f, 0xcb, 0x4e, 0xc8,
+		0x2a, 0xa3, 0x8a, 0x73, 0x9f, 0x69, 0xc2, 0x89, 0xb0, 0xec, 0xa4, 0x3c, 0x31, 0x52, 0x20, 0xee,
+		0xa6, 0x71, 0x26, 0x1f, 0x8a, 0xcb, 0x4e, 0x91, 0x30, 0x47, 0xef, 0x86, 0x59, 0x7f, 0xa8, 0x3b,
+		0xdd, 0xa9, 0xb3, 0xec, 0x94, 0x19, 0x69, 0x42, 0xdf, 0x1f, 0xf7, 0x4e, 0x77, 0x0a, 0x2d, 0x3b,
+		0x65, 0x82, 0x1a, 0x3d, 0x0f, 0x73, 0xc3, 0x71, 0xe9, 0xf4, 0x87, 0xd2, 0xb2, 0x87, 0x48, 0x59,
+		0xa3, 0x0e, 0xa0, 0x11, 0xf1, 0xec, 0x21, 0xce, 0xa8, 0x65, 0x0f, 0x93, 0xc1, 0x46, 0x2d, 0x48,
+		0x0f, 0x06, 0x89, 0xd3, 0x9e, 0x59, 0xcb, 0x4e, 0x9d, 0xcd, 0x66, 0xad, 0xf8, 0x83, 0xcb, 0x69,
+		0xcf, 0xb0, 0x65, 0xa7, 0x4e, 0x6e, 0xa3, 0x4d, 0x00, 0x4f, 0x7c, 0x38, 0xc5, 0x99, 0xb6, 0xec,
+		0x34, 0x69, 0x6e, 0xd4, 0x85, 0xf9, 0x51, 0x81, 0xe3, 0x61, 0x8e, 0xb8, 0x65, 0x0f, 0x95, 0xfd,
+		0x26, 0xfa, 0xec, 0x0f, 0x01, 0xa7, 0x3b, 0xf2, 0x96, 0x9d, 0x32, 0x0d, 0x5e, 0xc8, 0x8f, 0x3d,
+		0xe7, 0x7c, 0xdf, 0x81, 0xe7, 0x9c, 0xdd, 0x93, 0xcb, 0xce, 0xd9, 0xe6, 0xdf, 0x7d, 0x18, 0xde,
+		0xc1, 0x5f, 0xd0, 0xb1, 0x6c, 0xed, 0x86, 0x6e, 0xec, 0x38, 0xcf, 0x2c, 0xf1, 0x6f, 0x7e, 0xc8,
+		0xf9, 0x28, 0x7f, 0xa5, 0x47, 0x94, 0x4e, 0x78, 0x6c, 0x69, 0xec, 0x0b, 0x94, 0x93, 0xee, 0x43,
+		0x4c, 0x3e, 0xbe, 0x7c, 0xc0, 0x43, 0x4e, 0x13, 0x9e, 0x8b, 0x1a, 0xf1, 0xd0, 0x53, 0xf6, 0xc0,
+		0x37, 0x06, 0xb2, 0x07, 0x9d, 0xfb, 0x26, 0x5e, 0x6c, 0xea, 0x8a, 0x6e, 0xd9, 0x66, 0x4f, 0x6f,
+		0x6a, 0x6d, 0xba, 0xbc, 0x5c, 0x9c, 0xf6, 0x56, 0x56, 0x21, 0x4e, 0xdc, 0x15, 0xfe, 0x16, 0x14,
+		0xbf, 0x29, 0x54, 0x82, 0xc8, 0x4d, 0xad, 0xcd, 0xee, 0x44, 0x79, 0x1f, 0x82, 0x1b, 0x94, 0xb9,
+		0xc7, 0x8f, 0xf2, 0x52, 0x61, 0xb8, 0xb9, 0x1f, 0xa2, 0xf7, 0x49, 0x3a, 0x1d, 0xdd, 0x22, 0xba,
+		0xa8, 0xd0, 0x50, 0xfa, 0x2a, 0x84, 0x7a, 0x9a, 0xcd, 0x03, 0xcc, 0xc2, 0xf9, 0x43, 0xbf, 0xcb,
+		0xc4, 0x5a, 0xa0, 0x34, 0xd0, 0xd3, 0x10, 0xeb, 0x68, 0x7b, 0x2a, 0xa5, 0x17, 0xf8, 0x86, 0xe8,
+		0x45, 0x3b, 0xda, 0x1e, 0xe1, 0x0f, 0xbd, 0x9b, 0xfe, 0xfc, 0xa0, 0xda, 0xdc, 0xd5, 0x8c, 0x1d,
+		0xcc, 0x28, 0x07, 0xbf, 0x21, 0xca, 0xb3, 0x1d, 0x6d, 0xaf, 0x48, 0xa9, 0x11, 0xfa, 0xfc, 0xc9,
+		0xab, 0x5f, 0x97, 0x78, 0xd6, 0x80, 0x0a, 0x06, 0x69, 0x20, 0x37, 0x9d, 0x2f, 0xda, 0xa8, 0xd8,
+		0xe2, 0xb8, 0x6f, 0x9c, 0xdc, 0x07, 0xc4, 0x5a, 0x98, 0x25, 0xec, 0x7d, 0xfe, 0xb5, 0x45, 0x89,
+		0xb5, 0x9a, 0x6e, 0x0e, 0x89, 0x3d, 0xc1, 0x92, 0x21, 0x2a, 0xf5, 0x61, 0x03, 0x13, 0x7d, 0xd8,
+		0x59, 0xe1, 0xc3, 0x32, 0x82, 0xc0, 0xb0, 0x49, 0x3d, 0xef, 0xc3, 0xa7, 0x24, 0x48, 0x94, 0x3c,
+		0xcf, 0x3a, 0x66, 0x20, 0xda, 0x31, 0x0d, 0xfd, 0x06, 0xee, 0x39, 0x7b, 0x54, 0xec, 0x93, 0xf8,
+		0x99, 0xec, 0xc7, 0xa8, 0xed, 0x7d, 0xf1, 0xba, 0x90, 0xf8, 0x26, 0x58, 0x2f, 0xe0, 0x2d, 0x4b,
+		0x17, 0x72, 0x56, 0xc4, 0x27, 0xba, 0x1f, 0x64, 0x0b, 0x37, 0xfb, 0x3d, 0xdd, 0xde, 0x57, 0x9b,
+		0xa6, 0x61, 0x6b, 0x4d, 0x9b, 0xc7, 0xe1, 0x69, 0x51, 0x5e, 0x64, 0xc5, 0x84, 0x48, 0x0b, 0xdb,
+		0x9a, 0xde, 0x66, 0x27, 0x33, 0xe3, 0x8a, 0xf8, 0xe4, 0xac, 0xbe, 0x12, 0xf5, 0xc6, 0xa1, 0x45,
+		0x90, 0xcd, 0x2e, 0xee, 0xf9, 0x0e, 0xa4, 0x30, 0x6d, 0xcc, 0xfc, 0xce, 0x67, 0x1f, 0x5a, 0xe0,
+		0x02, 0xe7, 0x87, 0x19, 0xd8, 0xaf, 0x18, 0x28, 0x69, 0x81, 0x21, 0x4e, 0xaa, 0x5c, 0xf7, 0xed,
+		0x4a, 0xf5, 0xb7, 0xdc, 0x67, 0x64, 0x16, 0x86, 0x84, 0x9a, 0x37, 0xf6, 0x0b, 0x99, 0xcf, 0xb9,
+		0xa4, 0xdd, 0x38, 0xf5, 0x29, 0xbc, 0xef, 0xdd, 0xa2, 0xa2, 0x64, 0x88, 0x0b, 0xff, 0xbc, 0xa6,
+		0xb7, 0x71, 0x8b, 0xa7, 0x35, 0xf8, 0x17, 0x5a, 0x75, 0xd2, 0x8b, 0xec, 0x37, 0x35, 0x73, 0xe3,
+		0x74, 0xa3, 0x60, 0x1a, 0x2d, 0x7f, 0x1e, 0x11, 0x15, 0x21, 0x62, 0x9b, 0x37, 0xb0, 0xc1, 0x05,
+		0x74, 0xb8, 0xa7, 0xd5, 0x38, 0x2a, 0xfa, 0x56, 0x90, 0x5b, 0xb8, 0x8d, 0x77, 0xd8, 0x7d, 0xc9,
+		0x5d, 0xad, 0x87, 0xd9, 0x6d, 0xfd, 0xdb, 0x7a, 0x5e, 0x2d, 0xed, 0x90, 0xaa, 0x53, 0x4a, 0x68,
+		0xc3, 0xff, 0x70, 0x68, 0x94, 0x6f, 0x1e, 0x8f, 0xe9, 0xa3, 0x47, 0xf3, 0xbc, 0x96, 0xc7, 0xf7,
+		0xd0, 0xe8, 0xfd, 0x20, 0xf7, 0x8d, 0x2d, 0xd3, 0xa0, 0x3f, 0x10, 0xc9, 0xa3, 0xa8, 0x18, 0xdb,
+		0xa9, 0x74, 0xca, 0xf9, 0x4e, 0xe5, 0x06, 0xa4, 0x5c, 0x50, 0x3a, 0x43, 0xe2, 0x87, 0x9d, 0x21,
+		0xb3, 0x0e, 0x01, 0x02, 0x82, 0xd6, 0x01, 0xdc, 0x39, 0x48, 0xb7, 0xca, 0x12, 0xe3, 0x47, 0xcc,
+		0x9d, 0xcd, 0xde, 0xce, 0x78, 0x08, 0xa0, 0x6f, 0x81, 0xf9, 0x8e, 0x6e, 0xa8, 0x16, 0x6e, 0x6f,
+		0xab, 0x5c, 0x72, 0x84, 0x6e, 0xe2, 0xf0, 0xa3, 0x39, 0xd7, 0xd1, 0x8d, 0x3a, 0x6e, 0x6f, 0x97,
+		0x1c, 0x2a, 0xe8, 0x9d, 0x70, 0xc2, 0xed, 0xbd, 0x69, 0xa8, 0xbb, 0x66, 0xbb, 0xa5, 0xf6, 0xf0,
+		0xb6, 0xda, 0xa4, 0xef, 0xfc, 0x25, 0xa9, 0xcc, 0x8e, 0x39, 0x20, 0x35, 0xe3, 0x8a, 0xd9, 0x6e,
+		0x29, 0x78, 0xbb, 0x48, 0xaa, 0xd1, 0xdd, 0xe0, 0x76, 0x5d, 0xd5, 0x5b, 0x56, 0x66, 0x76, 0x29,
+		0x78, 0x2a, 0xa4, 0x24, 0x9d, 0xc2, 0x4a, 0xcb, 0x5a, 0x8d, 0xbd, 0xfc, 0xd1, 0xc5, 0x99, 0x37,
+		0x3e, 0xba, 0x38, 0x93, 0xbb, 0x44, 0xdf, 0x94, 0xe2, 0xf3, 0x08, 0x5b, 0xe8, 0x3c, 0xc4, 0x35,
+		0xf1, 0xc1, 0x6e, 0x8c, 0x1d, 0x30, 0x0f, 0x5d, 0xd0, 0xdc, 0x4f, 0x49, 0x10, 0x29, 0x5d, 0xdb,
+		0xd0, 0xf4, 0x1e, 0x2a, 0xc3, 0x9c, 0xab, 0x98, 0xd3, 0x4e, 0x69, 0x57, 0x97, 0xc5, 0x9c, 0xae,
+		0x8e, 0x3b, 0xaa, 0x16, 0x2f, 0xdc, 0xf5, 0x3b, 0x9f, 0x7d, 0xe8, 0x4e, 0x4e, 0xe6, 0xda, 0xc0,
+		0xa9, 0x35, 0x41, 0x6f, 0xf0, 0x34, 0x9b, 0xa7, 0xcf, 0x57, 0x21, 0xca, 0x58, 0xb5, 0xd0, 0x93,
+		0x10, 0xee, 0x92, 0x3f, 0x78, 0x06, 0xfe, 0xe4, 0x58, 0x05, 0xa7, 0xf0, 0x5e, 0x75, 0x60, 0x78,
+		0xb9, 0xf7, 0x07, 0x00, 0x4a, 0xd7, 0xae, 0x35, 0x7a, 0x7a, 0xb7, 0x8d, 0xed, 0xb7, 0xaa, 0xef,
+		0x9b, 0x70, 0xc4, 0x73, 0x17, 0xba, 0xd7, 0x3c, 0x7c, 0xff, 0xe7, 0xdd, 0x6b, 0xd1, 0xbd, 0xe6,
+		0x48, 0xb2, 0x2d, 0xcb, 0x76, 0xc8, 0x06, 0x0f, 0x4f, 0xb6, 0x64, 0xd9, 0xc3, 0x92, 0x7d, 0x16,
+		0x12, 0xae, 0x30, 0x2c, 0x54, 0x81, 0x98, 0xcd, 0xff, 0xe6, 0x02, 0xce, 0x8d, 0x17, 0xb0, 0x40,
+		0xf3, 0x0a, 0xd9, 0x41, 0xcf, 0xfd, 0xb5, 0x04, 0xe0, 0x99, 0x23, 0x6f, 0x4f, 0x1d, 0x23, 0xe1,
+		0x3a, 0xb7, 0xc4, 0xc1, 0xdb, 0x7e, 0x8d, 0x93, 0x11, 0xf0, 0x08, 0xf5, 0x03, 0x01, 0x98, 0xdf,
+		0x14, 0xb3, 0xf7, 0xed, 0x2f, 0x83, 0x4d, 0x88, 0x62, 0xc3, 0xee, 0xe9, 0xce, 0x1e, 0xd2, 0xc3,
+		0xe3, 0xc6, 0x7c, 0x44, 0xa7, 0xca, 0x86, 0xdd, 0xdb, 0xf7, 0x6a, 0x80, 0xa0, 0xe5, 0x91, 0xc7,
+		0x87, 0x83, 0x90, 0x19, 0x87, 0x8a, 0xee, 0x83, 0x74, 0xb3, 0x87, 0x69, 0x81, 0xff, 0x8a, 0x68,
+		0x4a, 0x14, 0xf3, 0x35, 0x46, 0x01, 0xe2, 0x95, 0x11, 0xe5, 0x22, 0xa0, 0xb7, 0xe7, 0x86, 0xa5,
+		0x5c, 0x0a, 0x74, 0x95, 0x69, 0x40, 0x5a, 0xdc, 0x39, 0xd9, 0xd2, 0xda, 0x9a, 0xd1, 0x14, 0xee,
+		0xea, 0xa1, 0x96, 0x04, 0x71, 0x6f, 0xa5, 0xc0, 0x48, 0xa0, 0x32, 0x44, 0x05, 0xb5, 0xd0, 0xe1,
+		0xa9, 0x09, 0x5c, 0x74, 0x17, 0x24, 0xbd, 0x0b, 0x03, 0x75, 0x3d, 0x42, 0x4a, 0xc2, 0xb3, 0x2e,
+		0x4c, 0x5a, 0x79, 0x22, 0x07, 0xae, 0x3c, 0xdc, 0xbb, 0xfb, 0x71, 0x7a, 0x34, 0xbc, 0xf5, 0xb7,
+		0x7f, 0x58, 0x36, 0x00, 0xd8, 0x54, 0x25, 0x96, 0x94, 0x8f, 0xcc, 0x6d, 0xcc, 0xf7, 0x38, 0x23,
+		0x52, 0xb2, 0xec, 0xbf, 0xa9, 0x11, 0xfa, 0x83, 0x00, 0x24, 0xbd, 0x23, 0xf4, 0x77, 0x72, 0xd1,
+		0x42, 0x55, 0xd7, 0x4c, 0xb1, 0xeb, 0x33, 0xf7, 0x8f, 0x33, 0x53, 0x43, 0xda, 0x3c, 0xc1, 0x3e,
+		0x7d, 0x22, 0x04, 0x11, 0x7e, 0xbe, 0xad, 0x36, 0xe4, 0xc8, 0x4a, 0x93, 0x1e, 0x00, 0x98, 0x15,
+		0x0f, 0x00, 0x8c, 0xf4, 0x63, 0xef, 0x81, 0x14, 0x09, 0x88, 0x7d, 0x87, 0xe6, 0xa4, 0x53, 0xb3,
+		0x34, 0xae, 0x75, 0x8f, 0x88, 0xa3, 0x45, 0x48, 0x10, 0x30, 0xd7, 0x0e, 0x13, 0x18, 0xe8, 0x68,
+		0x7b, 0x65, 0x56, 0x82, 0x1e, 0x02, 0xb4, 0xeb, 0x24, 0x28, 0x54, 0x57, 0x10, 0x04, 0x6e, 0xce,
+		0xad, 0x11, 0xe0, 0x77, 0x02, 0x10, 0x2e, 0x54, 0xf6, 0x00, 0x35, 0x7f, 0xde, 0x9b, 0x94, 0x94,
+		0xe8, 0x23, 0xd4, 0xef, 0x93, 0x98, 0x3f, 0x3c, 0x10, 0x36, 0xf3, 0x70, 0xa4, 0x31, 0xc5, 0xa4,
+		0xf8, 0x8b, 0xd7, 0x16, 0xb3, 0xfb, 0x5a, 0xa7, 0xbd, 0x9a, 0x1b, 0x41, 0x27, 0x37, 0x2a, 0x92,
+		0x27, 0x8e, 0xb3, 0x3f, 0xec, 0x66, 0x6c, 0x68, 0x7b, 0x43, 0x6c, 0x44, 0x6f, 0x87, 0x8d, 0x61,
+		0x3a, 0x63, 0xd8, 0xd0, 0xf6, 0xfc, 0x6c, 0xac, 0xbe, 0x83, 0xcc, 0xb2, 0x57, 0x5e, 0xff, 0xf4,
+		0xe9, 0x13, 0x9e, 0xa7, 0xa7, 0xf7, 0x9c, 0x2c, 0x1a, 0x53, 0x0d, 0xe2, 0x30, 0x23, 0x77, 0xf1,
+		0x72, 0x0e, 0xe8, 0xaf, 0x03, 0x78, 0x02, 0x0a, 0xe9, 0xe0, 0x40, 0xc5, 0xc5, 0xf7, 0x05, 0x2a,
+		0x9e, 0xa9, 0xfd, 0x2e, 0x77, 0xed, 0x10, 0x4f, 0x4f, 0x8c, 0x78, 0x18, 0x7d, 0xb9, 0x68, 0xea,
+		0x3e, 0x12, 0x02, 0x89, 0x5a, 0x8c, 0x99, 0xdc, 0xbf, 0x97, 0xe0, 0xf8, 0xd0, 0x2c, 0x70, 0x58,
+		0x6e, 0x02, 0xea, 0x79, 0x2a, 0xa9, 0x36, 0x89, 0x1d, 0xe1, 0xdb, 0x9b, 0x54, 0x73, 0xbd, 0xa1,
+		0x05, 0xe4, 0xad, 0x59, 0x04, 0xb9, 0x05, 0xfc, 0x4d, 0x09, 0x16, 0xbc, 0x0c, 0x38, 0x5d, 0xa9,
+		0x43, 0xd2, 0xdb, 0x34, 0xef, 0xc4, 0x3b, 0xa6, 0xe9, 0x84, 0x97, 0x7f, 0x1f, 0x11, 0x74, 0xcd,
+		0xb5, 0x34, 0x2c, 0x7d, 0x77, 0x76, 0x6a, 0xa1, 0x08, 0xc6, 0x46, 0x5a, 0x1c, 0x36, 0x36, 0x5f,
+		0x91, 0x20, 0xb4, 0x61, 0x9a, 0x6d, 0xf4, 0x1e, 0x98, 0x33, 0x4c, 0x5b, 0x25, 0xb3, 0x12, 0xb7,
+		0x54, 0x9e, 0x5f, 0x60, 0x56, 0xbc, 0x7c, 0xa0, 0xac, 0xbe, 0xfc, 0xda, 0xe2, 0x30, 0xe6, 0xa8,
+		0xa7, 0xe9, 0xd3, 0x86, 0x69, 0x17, 0x28, 0x50, 0x83, 0xa5, 0x20, 0xb6, 0x61, 0xd6, 0xdf, 0x1c,
+		0xb3, 0xf4, 0xf9, 0x49, 0xcd, 0xcd, 0x4e, 0x6c, 0x2a, 0xb9, 0xe5, 0x69, 0x87, 0xbd, 0xe6, 0xfc,
+		0x67, 0x64, 0xe4, 0xae, 0x83, 0x7c, 0x6d, 0xf0, 0xa4, 0x51, 0x19, 0xa2, 0xe2, 0x64, 0x91, 0x34,
+		0xe5, 0xa1, 0x25, 0xaf, 0x38, 0x39, 0xee, 0xe9, 0x5f, 0x94, 0x00, 0xdc, 0x5c, 0x0d, 0x7a, 0x10,
+		0x8e, 0x15, 0x6a, 0xd5, 0x92, 0x5a, 0x6f, 0xe4, 0x1b, 0x9b, 0x75, 0xff, 0x0f, 0x9a, 0x88, 0x67,
+		0x90, 0xac, 0x2e, 0x6e, 0xea, 0xdb, 0x3a, 0x6e, 0xa1, 0x7b, 0x61, 0xc1, 0x0f, 0x4d, 0xbe, 0xca,
+		0x25, 0x59, 0xca, 0x26, 0x5f, 0xb9, 0xb5, 0x14, 0x63, 0xee, 0x2a, 0x6e, 0xa1, 0x53, 0x70, 0x64,
+		0x18, 0xae, 0x52, 0xbd, 0x2c, 0x07, 0xb2, 0xb3, 0xaf, 0xdc, 0x5a, 0x8a, 0x3b, 0x7e, 0x2d, 0xca,
+		0x01, 0xf2, 0x42, 0x72, 0x7a, 0xc1, 0x2c, 0xbc, 0x72, 0x6b, 0x29, 0xc2, 0x46, 0x21, 0x1b, 0x7a,
+		0xf9, 0x13, 0x27, 0x67, 0x4e, 0x7f, 0x1b, 0x40, 0xc5, 0xd8, 0xee, 0x69, 0xf4, 0x57, 0xfd, 0x51,
+		0x16, 0x8e, 0x56, 0xaa, 0x97, 0x94, 0x7c, 0xb1, 0x51, 0xa9, 0x55, 0x07, 0x7e, 0x87, 0xc5, 0x5f,
+		0x57, 0xaa, 0x6d, 0x16, 0xd6, 0xca, 0x6a, 0xbd, 0x72, 0xb9, 0xca, 0xf6, 0x7c, 0x7d, 0x75, 0xcf,
+		0x54, 0x1b, 0x95, 0xf5, 0xb2, 0x1c, 0x28, 0x5c, 0x1a, 0xbb, 0xa7, 0xf0, 0xe0, 0x81, 0x8f, 0xed,
+		0xbb, 0x16, 0xcf, 0xb7, 0xb1, 0xf0, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x84, 0x7c, 0x8c, 0x79,
+		0x0d, 0xb3, 0x00, 0x00,
 	}
 	r := bytes.NewReader(gzipped)
 	gzipr, err := compress_gzip.NewReader(r)
@@ -2418,6 +2424,9 @@ func (this *Params) Equal(that interface{}) bool {
 	if !this.MinCommissionRate.Equal(that1.MinCommissionRate) {
 		return false
 	}
+	if !this.MaxCommissionRate.Equal(that1.MaxCommissionRate) {
+		return false
+	}
 	return true
 }
 func (this *RedelegationEntryResponse) Equal(that interface{}) bool {
@@ -3311,6 +3320,16 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	{
+		size := m.MaxCommissionRate.Size()
+		i -= size
+		if _, err := m.MaxCommissionRate.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x3a
 	{
 		size := m.MinCommissionRate.Size()
 		i -= size
@@ -3923,6 +3942,8 @@ func (m *Params) Size() (n int) {
 	}
 	l = m.MinCommissionRate.Size()
 	n += 1 + l + sovStaking(uint64(l))
+	l = m.MaxCommissionRate.Size()
+	n += 1 + l + sovStaking(uint64(l))
 	return n
 }
 
@@ -6657,6 +6678,40 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxCommissionRate", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.MaxCommissionRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStaking(dAtA[iNdEx:])

From 1337d64bb57376ccdf74f29fbb03813c7ce44f32 Mon Sep 17 00:00:00 2001
From: Pantani <danpantani@gmail.com>
Date: Mon, 22 Sep 2025 18:48:23 -0300
Subject: [PATCH 2/9] fix simulation

---
 x/staking/simulation/operations.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/x/staking/simulation/operations.go b/x/staking/simulation/operations.go
index fcfa7e58c2b3..e0eef2263f67 100644
--- a/x/staking/simulation/operations.go
+++ b/x/staking/simulation/operations.go
@@ -164,7 +164,7 @@ func SimulateMsgCreateValidator(
 			simtypes.RandStringOfLength(r, 10),
 		)
 
-		maxCommission := math.LegacyNewDecWithPrec(int64(simtypes.RandIntBetween(r, 0, 100)), 2)
+		maxCommission := math.LegacyNewDecWithPrec(int64(simtypes.RandIntBetween(r, types.DefaultMinCommission, types.DefaultMaxCommission)), 2)
 		commission := types.NewCommissionRates(
 			simtypes.RandomDecAmount(r, maxCommission),
 			maxCommission,

From 0d73e22a8149228523d41badb73b3c13990ae825 Mon Sep 17 00:00:00 2001
From: Pantani <danpantani@gmail.com>
Date: Mon, 22 Sep 2025 18:51:04 -0300
Subject: [PATCH 3/9] fix max/min logic

---
 x/staking/keeper/msg_server.go | 40 +++++++++++++++++++---------------
 1 file changed, 22 insertions(+), 18 deletions(-)

diff --git a/x/staking/keeper/msg_server.go b/x/staking/keeper/msg_server.go
index a89bd7a2e8e7..e29c33f5f5c0 100644
--- a/x/staking/keeper/msg_server.go
+++ b/x/staking/keeper/msg_server.go
@@ -53,16 +53,18 @@ func (k msgServer) CreateValidator(ctx context.Context, msg *types.MsgCreateVali
 		return nil, err
 	}
 
-	if maxCommRate.Equal(minCommRate) && !msg.Commission.Rate.Equal(minCommRate) {
-		return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate must be equal too", minCommRate.String())
-	}
-
-	if msg.Commission.Rate.LT(minCommRate) {
-		return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "cannot set validator commission to less than minimum rate of %s", minCommRate.String())
-	}
+	if maxCommRate.Equal(minCommRate) {
+		if !msg.Commission.Rate.Equal(minCommRate) {
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate must be equal too", minCommRate.String())
+		}
+	} else {
+		if msg.Commission.Rate.LT(minCommRate) {
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "cannot set validator commission to less than minimum rate of %s", minCommRate.String())
+		}
 
-	if msg.Commission.Rate.GT(maxCommRate) {
-		return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator commission to more than minimum rate of %s", maxCommRate.String())
+		if msg.Commission.Rate.GT(maxCommRate) {
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator commission to more than minimum rate of %s", maxCommRate.String())
+		}
 	}
 
 	// check to see if the pubkey or sender has been registered before
@@ -202,16 +204,18 @@ func (k msgServer) EditValidator(ctx context.Context, msg *types.MsgEditValidato
 			return nil, err
 		}
 
-		if maxCommissionRate.Equal(minCommissionRate) && !msg.CommissionRate.Equal(minCommissionRate) {
-			return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate must be equal too", minCommissionRate.String())
-		}
-
-		if msg.CommissionRate.LT(minCommissionRate) {
-			return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "commission rate cannot be less than the min commission rate %s", minCommissionRate.String())
-		}
+		if maxCommissionRate.Equal(minCommissionRate) {
+			if !msg.CommissionRate.Equal(minCommissionRate) {
+				return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate must be equal too", minCommissionRate.String())
+			}
+		} else {
+			if msg.CommissionRate.LT(minCommissionRate) {
+				return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "commission rate cannot be less than the min commission rate %s", minCommissionRate.String())
+			}
 
-		if msg.CommissionRate.GT(maxCommissionRate) {
-			return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator commission to more than minimum rate of %s", maxCommissionRate.String())
+			if msg.CommissionRate.GT(maxCommissionRate) {
+				return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator commission to more than minimum rate of %s", maxCommissionRate.String())
+			}
 		}
 	}
 

From 113ddb1eb25c44acbdd907d8e69c6d966cf600d1 Mon Sep 17 00:00:00 2001
From: Pantani <danpantani@gmail.com>
Date: Mon, 22 Sep 2025 19:06:03 -0300
Subject: [PATCH 4/9] fix commission rate for simulation operations

---
 x/staking/keeper/msg_server.go     | 12 ++++++------
 x/staking/simulation/operations.go | 28 +++++++++++++++++++++++-----
 2 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/x/staking/keeper/msg_server.go b/x/staking/keeper/msg_server.go
index e29c33f5f5c0..6d4c31761344 100644
--- a/x/staking/keeper/msg_server.go
+++ b/x/staking/keeper/msg_server.go
@@ -55,15 +55,15 @@ func (k msgServer) CreateValidator(ctx context.Context, msg *types.MsgCreateVali
 
 	if maxCommRate.Equal(minCommRate) {
 		if !msg.Commission.Rate.Equal(minCommRate) {
-			return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate must be equal too", minCommRate.String())
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate (%s) must be equal too", minCommRate.String(), msg.Commission.Rate.String())
 		}
 	} else {
 		if msg.Commission.Rate.LT(minCommRate) {
-			return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "cannot set validator commission to less than minimum rate of %s", minCommRate.String())
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "cannot set validator commission (%s) to less than minimum rate of %s", msg.Commission.Rate.String(), minCommRate.String())
 		}
 
 		if msg.Commission.Rate.GT(maxCommRate) {
-			return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator commission to more than minimum rate of %s", maxCommRate.String())
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator commission (%s) to more than minimum rate of %s", msg.Commission.Rate.String(), maxCommRate.String())
 		}
 	}
 
@@ -206,15 +206,15 @@ func (k msgServer) EditValidator(ctx context.Context, msg *types.MsgEditValidato
 
 		if maxCommissionRate.Equal(minCommissionRate) {
 			if !msg.CommissionRate.Equal(minCommissionRate) {
-				return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate must be equal too", minCommissionRate.String())
+				return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate (%s) must be equal too", msg.CommissionRate.String(), minCommissionRate.String())
 			}
 		} else {
 			if msg.CommissionRate.LT(minCommissionRate) {
-				return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "commission rate cannot be less than the min commission rate %s", minCommissionRate.String())
+				return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "commission rate (%s) cannot be less than the min commission rate %s", msg.CommissionRate.String(), minCommissionRate.String())
 			}
 
 			if msg.CommissionRate.GT(maxCommissionRate) {
-				return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator commission to more than minimum rate of %s", maxCommissionRate.String())
+				return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator (%s) commission to more than minimum rate of %s", msg.CommissionRate.String(), maxCommissionRate.String())
 			}
 		}
 	}
diff --git a/x/staking/simulation/operations.go b/x/staking/simulation/operations.go
index e0eef2263f67..3980e89ba2cf 100644
--- a/x/staking/simulation/operations.go
+++ b/x/staking/simulation/operations.go
@@ -164,11 +164,20 @@ func SimulateMsgCreateValidator(
 			simtypes.RandStringOfLength(r, 10),
 		)
 
-		maxCommission := math.LegacyNewDecWithPrec(int64(simtypes.RandIntBetween(r, types.DefaultMinCommission, types.DefaultMaxCommission)), 2)
+		minCommRate, err := k.MinCommissionRate(ctx)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, msgType, "unable to get min commission rate"), nil, err
+		}
+		maxCommRate, err := k.MinCommissionRate(ctx)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, msgType, "unable to get max commission rate"), nil, err
+		}
+
+		commissionRate := simtypes.RandomDecAmount(r, maxCommRate.Sub(minCommRate)).Add(minCommRate)
 		commission := types.NewCommissionRates(
-			simtypes.RandomDecAmount(r, maxCommission),
-			maxCommission,
-			simtypes.RandomDecAmount(r, maxCommission),
+			commissionRate,
+			maxCommRate,
+			simtypes.RandomDecAmount(r, maxCommRate),
 		)
 
 		msg, err := types.NewMsgCreateValidator(address.String(), simAccount.ConsKey.PubKey(), selfDelegation, description, commission, math.OneInt())
@@ -219,8 +228,17 @@ func SimulateMsgEditValidator(
 		}
 
 		address := val.GetOperator()
-		newCommissionRate := simtypes.RandomDecAmount(r, val.Commission.MaxRate)
 
+		minCommRate, err := k.MinCommissionRate(ctx)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, msgType, "unable to get min commission rate"), nil, err
+		}
+		maxCommRate, err := k.MinCommissionRate(ctx)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, msgType, "unable to get max commission rate"), nil, err
+		}
+
+		newCommissionRate := simtypes.RandomDecAmount(r, maxCommRate.Sub(minCommRate)).Add(minCommRate)
 		if err := val.Commission.ValidateNewRate(newCommissionRate, ctx.BlockHeader().Time); err != nil {
 			// skip as the commission is invalid
 			return simtypes.NoOpMsg(types.ModuleName, msgType, "invalid commission rate"), nil, nil

From f10a50d3fbb9085c4dcefa9a3b95f552b9186607 Mon Sep 17 00:00:00 2001
From: Pantani <danpantani@gmail.com>
Date: Mon, 22 Sep 2025 19:10:02 -0300
Subject: [PATCH 5/9] set DefaultMinCommissionRate to zero

---
 x/staking/types/params.go | 32 +-------------------------------
 1 file changed, 1 insertion(+), 31 deletions(-)

diff --git a/x/staking/types/params.go b/x/staking/types/params.go
index e17c81aeb9ee..3b4d85935b84 100644
--- a/x/staking/types/params.go
+++ b/x/staking/types/params.go
@@ -30,17 +30,13 @@ const (
 	// SetOrderBeginBlockers.
 	DefaultHistoricalEntries uint32 = 10000
 
-	// DefaultMinCommission default minimum commission.
-	// SetOrderBeginBlockers.
-	DefaultMinCommission = 1
-
 	// DefaultMaxCommission default maximum commission.
 	DefaultMaxCommission = 100 // 30% (30/100 = 0.3 = 30%
 )
 
 var (
 	// DefaultMinCommissionRate is set to 0%
-	DefaultMinCommissionRate = math.LegacyNewDecWithPrec(DefaultMinCommission, 2)
+	DefaultMinCommissionRate = math.LegacyZeroDec()
 
 	// DefaultMaxCommissionRate is set to 0%
 	DefaultMaxCommissionRate = math.LegacyNewDecWithPrec(DefaultMaxCommission, 2)
@@ -236,29 +232,3 @@ func validateMaxCommissionRate(i interface{}) error {
 
 	return nil
 }
-
-func validateCommissionRate(minimum, maximum interface{}) error {
-	if err := validateMinCommissionRate(minimum); err != nil {
-		return err
-	}
-
-	if err := validateMaxCommissionRate(maximum); err != nil {
-		return err
-	}
-
-	vMin, ok := minimum.(math.LegacyDec)
-	if !ok {
-		return fmt.Errorf("invalid minimum parameter type: %T", minimum)
-	}
-
-	vMax, ok := maximum.(math.LegacyDec)
-	if !ok {
-		return fmt.Errorf("invalid maximum parameter type: %T", maximum)
-	}
-
-	if vMin.GT(vMax) {
-		return fmt.Errorf("minimum commission (%s) rate cannot be greater than the maximum (%s)", vMin.String(), vMax.String())
-	}
-
-	return nil
-}

From d597cf92273f87206b1e08b3bc6703413708b8dc Mon Sep 17 00:00:00 2001
From: Pantani <danpantani@gmail.com>
Date: Mon, 22 Sep 2025 19:11:58 -0300
Subject: [PATCH 6/9] validate params

---
 x/staking/simulation/genesis.go |  2 +-
 x/staking/types/params.go       | 26 ++++++++++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/x/staking/simulation/genesis.go b/x/staking/simulation/genesis.go
index 51faef8a1c70..1377b1fc17da 100644
--- a/x/staking/simulation/genesis.go
+++ b/x/staking/simulation/genesis.go
@@ -78,7 +78,7 @@ func RandomizedGenState(simState *module.SimulationState) {
 		valAddr := sdk.ValAddress(simState.Accounts[i].Address)
 		valAddrs[i] = valAddr
 
-		maxCommission := sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(simState.Rand, types.DefaultMinCommission, types.DefaultMaxCommission)), 2)
+		maxCommission := sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(simState.Rand, 1, types.DefaultMaxCommission)), 2)
 		commission := types.NewCommission(
 			simulation.RandomDecAmount(simState.Rand, maxCommission),
 			maxCommission,
diff --git a/x/staking/types/params.go b/x/staking/types/params.go
index 3b4d85935b84..d298a182e3cf 100644
--- a/x/staking/types/params.go
+++ b/x/staking/types/params.go
@@ -232,3 +232,29 @@ func validateMaxCommissionRate(i interface{}) error {
 
 	return nil
 }
+
+func validateCommissionRate(minimum, maximum interface{}) error {
+	if err := validateMinCommissionRate(minimum); err != nil {
+		return err
+	}
+
+	if err := validateMaxCommissionRate(maximum); err != nil {
+		return err
+	}
+
+	vMin, ok := minimum.(math.LegacyDec)
+	if !ok {
+		return fmt.Errorf("invalid minimum parameter type: %T", minimum)
+	}
+
+	vMax, ok := maximum.(math.LegacyDec)
+	if !ok {
+		return fmt.Errorf("invalid maximum parameter type: %T", maximum)
+	}
+
+	if vMin.GT(vMax) {
+		return fmt.Errorf("minimum commission (%s) rate cannot be greater than the maximum (%s)", vMin.String(), vMax.String())
+	}
+
+	return nil
+}

From a5f90b1a9f72ef9c5163c4ccae0afa26fcf79ef0 Mon Sep 17 00:00:00 2001
From: Pantani <danpantani@gmail.com>
Date: Mon, 22 Sep 2025 22:26:43 -0300
Subject: [PATCH 7/9] fix test fixtures

---
 x/staking/migrations/v3/json_test.go | 1 +
 x/staking/simulation/genesis_test.go | 6 +++---
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/x/staking/migrations/v3/json_test.go b/x/staking/migrations/v3/json_test.go
index c111f366515e..438c24b52413 100644
--- a/x/staking/migrations/v3/json_test.go
+++ b/x/staking/migrations/v3/json_test.go
@@ -43,6 +43,7 @@ func TestMigrateJSON(t *testing.T) {
 	"params": {
 		"bond_denom": "stake",
 		"historical_entries": 10000,
+		"max_commission_rate": "1.000000000000000000",
 		"max_entries": 7,
 		"max_validators": 100,
 		"min_commission_rate": "0.000000000000000000",
diff --git a/x/staking/simulation/genesis_test.go b/x/staking/simulation/genesis_test.go
index d3b74e5758fe..47129c0d1f4b 100644
--- a/x/staking/simulation/genesis_test.go
+++ b/x/staking/simulation/genesis_test.go
@@ -64,9 +64,9 @@ func TestRandomizedGenState(t *testing.T) {
 	require.Equal(t, "BOND_STATUS_UNBONDED", stakingGenesis.Validators[2].Status.String())
 	require.Equal(t, "1000", stakingGenesis.Validators[2].Tokens.String())
 	require.Equal(t, "1000.000000000000000000", stakingGenesis.Validators[2].DelegatorShares.String())
-	require.Equal(t, "0.292059246265731326", stakingGenesis.Validators[2].Commission.CommissionRates.Rate.String())
-	require.Equal(t, "0.330000000000000000", stakingGenesis.Validators[2].Commission.CommissionRates.MaxRate.String())
-	require.Equal(t, "0.038337453731274481", stakingGenesis.Validators[2].Commission.CommissionRates.MaxChangeRate.String())
+	require.Equal(t, "0.760000000000000000", stakingGenesis.Validators[2].Commission.CommissionRates.Rate.String())
+	require.Equal(t, "0.760000000000000000", stakingGenesis.Validators[2].Commission.CommissionRates.MaxRate.String())
+	require.Equal(t, "0.312739151653465930", stakingGenesis.Validators[2].Commission.CommissionRates.MaxChangeRate.String())
 	require.Equal(t, "1", stakingGenesis.Validators[2].MinSelfDelegation.String())
 }
 

From 5c1bd582fee7fa937cab3a5ffd354ff1e6bba2b5 Mon Sep 17 00:00:00 2001
From: Pantani <danpantani@gmail.com>
Date: Mon, 22 Sep 2025 22:31:55 -0300
Subject: [PATCH 8/9] staking api

---
 .../cosmos/staking/v1beta1/authz.pulsar.go    |  1581 ++
 .../cosmos/staking/v1beta1/genesis.pulsar.go  |  2057 ++
 .../cosmos/staking/v1beta1/query.pulsar.go    | 15865 ++++++++++++++++
 .../cosmos/staking/v1beta1/query_grpc.pb.go   |   697 +
 .../cosmos/staking/v1beta1/staking.pulsar.go  | 14863 +++++++++++++++
 .../cosmos/staking/v1beta1/tx.pulsar.go       |  8317 ++++++++
 .../cosmos/staking/v1beta1/tx_grpc.pb.go      |   383 +
 tests/integration/rapidgen/rapidgen.go        |     2 +-
 .../tx/aminojson/aminojson_test.go            |     4 +-
 x/staking/autocli.go                          |     2 +-
 10 files changed, 43767 insertions(+), 4 deletions(-)
 create mode 100644 atomone-api/cosmos/staking/v1beta1/authz.pulsar.go
 create mode 100644 atomone-api/cosmos/staking/v1beta1/genesis.pulsar.go
 create mode 100644 atomone-api/cosmos/staking/v1beta1/query.pulsar.go
 create mode 100644 atomone-api/cosmos/staking/v1beta1/query_grpc.pb.go
 create mode 100644 atomone-api/cosmos/staking/v1beta1/staking.pulsar.go
 create mode 100644 atomone-api/cosmos/staking/v1beta1/tx.pulsar.go
 create mode 100644 atomone-api/cosmos/staking/v1beta1/tx_grpc.pb.go

diff --git a/atomone-api/cosmos/staking/v1beta1/authz.pulsar.go b/atomone-api/cosmos/staking/v1beta1/authz.pulsar.go
new file mode 100644
index 000000000000..6675b1355290
--- /dev/null
+++ b/atomone-api/cosmos/staking/v1beta1/authz.pulsar.go
@@ -0,0 +1,1581 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package stakingv1beta1
+
+import (
+	_ "cosmossdk.io/api/amino"
+	v1beta1 "cosmossdk.io/api/cosmos/base/v1beta1"
+	fmt "fmt"
+	_ "github.com/cosmos/cosmos-proto"
+	runtime "github.com/cosmos/cosmos-proto/runtime"
+	_ "github.com/cosmos/gogoproto/gogoproto"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	io "io"
+	reflect "reflect"
+	sync "sync"
+)
+
+var (
+	md_StakeAuthorization                    protoreflect.MessageDescriptor
+	fd_StakeAuthorization_max_tokens         protoreflect.FieldDescriptor
+	fd_StakeAuthorization_allow_list         protoreflect.FieldDescriptor
+	fd_StakeAuthorization_deny_list          protoreflect.FieldDescriptor
+	fd_StakeAuthorization_authorization_type protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_authz_proto_init()
+	md_StakeAuthorization = File_cosmos_staking_v1beta1_authz_proto.Messages().ByName("StakeAuthorization")
+	fd_StakeAuthorization_max_tokens = md_StakeAuthorization.Fields().ByName("max_tokens")
+	fd_StakeAuthorization_allow_list = md_StakeAuthorization.Fields().ByName("allow_list")
+	fd_StakeAuthorization_deny_list = md_StakeAuthorization.Fields().ByName("deny_list")
+	fd_StakeAuthorization_authorization_type = md_StakeAuthorization.Fields().ByName("authorization_type")
+}
+
+var _ protoreflect.Message = (*fastReflection_StakeAuthorization)(nil)
+
+type fastReflection_StakeAuthorization StakeAuthorization
+
+func (x *StakeAuthorization) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_StakeAuthorization)(x)
+}
+
+func (x *StakeAuthorization) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_authz_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_StakeAuthorization_messageType fastReflection_StakeAuthorization_messageType
+var _ protoreflect.MessageType = fastReflection_StakeAuthorization_messageType{}
+
+type fastReflection_StakeAuthorization_messageType struct{}
+
+func (x fastReflection_StakeAuthorization_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_StakeAuthorization)(nil)
+}
+func (x fastReflection_StakeAuthorization_messageType) New() protoreflect.Message {
+	return new(fastReflection_StakeAuthorization)
+}
+func (x fastReflection_StakeAuthorization_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_StakeAuthorization
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_StakeAuthorization) Descriptor() protoreflect.MessageDescriptor {
+	return md_StakeAuthorization
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_StakeAuthorization) Type() protoreflect.MessageType {
+	return _fastReflection_StakeAuthorization_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_StakeAuthorization) New() protoreflect.Message {
+	return new(fastReflection_StakeAuthorization)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_StakeAuthorization) Interface() protoreflect.ProtoMessage {
+	return (*StakeAuthorization)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_StakeAuthorization) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.MaxTokens != nil {
+		value := protoreflect.ValueOfMessage(x.MaxTokens.ProtoReflect())
+		if !f(fd_StakeAuthorization_max_tokens, value) {
+			return
+		}
+	}
+	if x.Validators != nil {
+		switch o := x.Validators.(type) {
+		case *StakeAuthorization_AllowList:
+			v := o.AllowList
+			value := protoreflect.ValueOfMessage(v.ProtoReflect())
+			if !f(fd_StakeAuthorization_allow_list, value) {
+				return
+			}
+		case *StakeAuthorization_DenyList:
+			v := o.DenyList
+			value := protoreflect.ValueOfMessage(v.ProtoReflect())
+			if !f(fd_StakeAuthorization_deny_list, value) {
+				return
+			}
+		}
+	}
+	if x.AuthorizationType != 0 {
+		value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.AuthorizationType))
+		if !f(fd_StakeAuthorization_authorization_type, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_StakeAuthorization) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.max_tokens":
+		return x.MaxTokens != nil
+	case "cosmos.staking.v1beta1.StakeAuthorization.allow_list":
+		if x.Validators == nil {
+			return false
+		} else if _, ok := x.Validators.(*StakeAuthorization_AllowList); ok {
+			return true
+		} else {
+			return false
+		}
+	case "cosmos.staking.v1beta1.StakeAuthorization.deny_list":
+		if x.Validators == nil {
+			return false
+		} else if _, ok := x.Validators.(*StakeAuthorization_DenyList); ok {
+			return true
+		} else {
+			return false
+		}
+	case "cosmos.staking.v1beta1.StakeAuthorization.authorization_type":
+		return x.AuthorizationType != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_StakeAuthorization) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.max_tokens":
+		x.MaxTokens = nil
+	case "cosmos.staking.v1beta1.StakeAuthorization.allow_list":
+		x.Validators = nil
+	case "cosmos.staking.v1beta1.StakeAuthorization.deny_list":
+		x.Validators = nil
+	case "cosmos.staking.v1beta1.StakeAuthorization.authorization_type":
+		x.AuthorizationType = 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_StakeAuthorization) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.max_tokens":
+		value := x.MaxTokens
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.StakeAuthorization.allow_list":
+		if x.Validators == nil {
+			return protoreflect.ValueOfMessage((*StakeAuthorization_Validators)(nil).ProtoReflect())
+		} else if v, ok := x.Validators.(*StakeAuthorization_AllowList); ok {
+			return protoreflect.ValueOfMessage(v.AllowList.ProtoReflect())
+		} else {
+			return protoreflect.ValueOfMessage((*StakeAuthorization_Validators)(nil).ProtoReflect())
+		}
+	case "cosmos.staking.v1beta1.StakeAuthorization.deny_list":
+		if x.Validators == nil {
+			return protoreflect.ValueOfMessage((*StakeAuthorization_Validators)(nil).ProtoReflect())
+		} else if v, ok := x.Validators.(*StakeAuthorization_DenyList); ok {
+			return protoreflect.ValueOfMessage(v.DenyList.ProtoReflect())
+		} else {
+			return protoreflect.ValueOfMessage((*StakeAuthorization_Validators)(nil).ProtoReflect())
+		}
+	case "cosmos.staking.v1beta1.StakeAuthorization.authorization_type":
+		value := x.AuthorizationType
+		return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_StakeAuthorization) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.max_tokens":
+		x.MaxTokens = value.Message().Interface().(*v1beta1.Coin)
+	case "cosmos.staking.v1beta1.StakeAuthorization.allow_list":
+		cv := value.Message().Interface().(*StakeAuthorization_Validators)
+		x.Validators = &StakeAuthorization_AllowList{AllowList: cv}
+	case "cosmos.staking.v1beta1.StakeAuthorization.deny_list":
+		cv := value.Message().Interface().(*StakeAuthorization_Validators)
+		x.Validators = &StakeAuthorization_DenyList{DenyList: cv}
+	case "cosmos.staking.v1beta1.StakeAuthorization.authorization_type":
+		x.AuthorizationType = (AuthorizationType)(value.Enum())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_StakeAuthorization) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.max_tokens":
+		if x.MaxTokens == nil {
+			x.MaxTokens = new(v1beta1.Coin)
+		}
+		return protoreflect.ValueOfMessage(x.MaxTokens.ProtoReflect())
+	case "cosmos.staking.v1beta1.StakeAuthorization.allow_list":
+		if x.Validators == nil {
+			value := &StakeAuthorization_Validators{}
+			oneofValue := &StakeAuthorization_AllowList{AllowList: value}
+			x.Validators = oneofValue
+			return protoreflect.ValueOfMessage(value.ProtoReflect())
+		}
+		switch m := x.Validators.(type) {
+		case *StakeAuthorization_AllowList:
+			return protoreflect.ValueOfMessage(m.AllowList.ProtoReflect())
+		default:
+			value := &StakeAuthorization_Validators{}
+			oneofValue := &StakeAuthorization_AllowList{AllowList: value}
+			x.Validators = oneofValue
+			return protoreflect.ValueOfMessage(value.ProtoReflect())
+		}
+	case "cosmos.staking.v1beta1.StakeAuthorization.deny_list":
+		if x.Validators == nil {
+			value := &StakeAuthorization_Validators{}
+			oneofValue := &StakeAuthorization_DenyList{DenyList: value}
+			x.Validators = oneofValue
+			return protoreflect.ValueOfMessage(value.ProtoReflect())
+		}
+		switch m := x.Validators.(type) {
+		case *StakeAuthorization_DenyList:
+			return protoreflect.ValueOfMessage(m.DenyList.ProtoReflect())
+		default:
+			value := &StakeAuthorization_Validators{}
+			oneofValue := &StakeAuthorization_DenyList{DenyList: value}
+			x.Validators = oneofValue
+			return protoreflect.ValueOfMessage(value.ProtoReflect())
+		}
+	case "cosmos.staking.v1beta1.StakeAuthorization.authorization_type":
+		panic(fmt.Errorf("field authorization_type of message cosmos.staking.v1beta1.StakeAuthorization is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_StakeAuthorization) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.max_tokens":
+		m := new(v1beta1.Coin)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.StakeAuthorization.allow_list":
+		value := &StakeAuthorization_Validators{}
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.StakeAuthorization.deny_list":
+		value := &StakeAuthorization_Validators{}
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.StakeAuthorization.authorization_type":
+		return protoreflect.ValueOfEnum(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_StakeAuthorization) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.validators":
+		if x.Validators == nil {
+			return nil
+		}
+		switch x.Validators.(type) {
+		case *StakeAuthorization_AllowList:
+			return x.Descriptor().Fields().ByName("allow_list")
+		case *StakeAuthorization_DenyList:
+			return x.Descriptor().Fields().ByName("deny_list")
+		}
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.StakeAuthorization", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_StakeAuthorization) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_StakeAuthorization) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_StakeAuthorization) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_StakeAuthorization) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*StakeAuthorization)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.MaxTokens != nil {
+			l = options.Size(x.MaxTokens)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		switch x := x.Validators.(type) {
+		case *StakeAuthorization_AllowList:
+			if x == nil {
+				break
+			}
+			l = options.Size(x.AllowList)
+			n += 1 + l + runtime.Sov(uint64(l))
+		case *StakeAuthorization_DenyList:
+			if x == nil {
+				break
+			}
+			l = options.Size(x.DenyList)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.AuthorizationType != 0 {
+			n += 1 + runtime.Sov(uint64(x.AuthorizationType))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*StakeAuthorization)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		switch x := x.Validators.(type) {
+		case *StakeAuthorization_AllowList:
+			encoded, err := options.Marshal(x.AllowList)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		case *StakeAuthorization_DenyList:
+			encoded, err := options.Marshal(x.DenyList)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.AuthorizationType != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.AuthorizationType))
+			i--
+			dAtA[i] = 0x20
+		}
+		if x.MaxTokens != nil {
+			encoded, err := options.Marshal(x.MaxTokens)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*StakeAuthorization)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: StakeAuthorization: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: StakeAuthorization: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaxTokens", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.MaxTokens == nil {
+					x.MaxTokens = &v1beta1.Coin{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MaxTokens); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AllowList", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				v := &StakeAuthorization_Validators{}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				x.Validators = &StakeAuthorization_AllowList{v}
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DenyList", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				v := &StakeAuthorization_Validators{}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				x.Validators = &StakeAuthorization_DenyList{v}
+				iNdEx = postIndex
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AuthorizationType", wireType)
+				}
+				x.AuthorizationType = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.AuthorizationType |= AuthorizationType(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_StakeAuthorization_Validators_1_list)(nil)
+
+type _StakeAuthorization_Validators_1_list struct {
+	list *[]string
+}
+
+func (x *_StakeAuthorization_Validators_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_StakeAuthorization_Validators_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_StakeAuthorization_Validators_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_StakeAuthorization_Validators_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_StakeAuthorization_Validators_1_list) AppendMutable() protoreflect.Value {
+	panic(fmt.Errorf("AppendMutable can not be called on message StakeAuthorization_Validators at list field Address as it is not of Message kind"))
+}
+
+func (x *_StakeAuthorization_Validators_1_list) Truncate(n int) {
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_StakeAuthorization_Validators_1_list) NewElement() protoreflect.Value {
+	v := ""
+	return protoreflect.ValueOfString(v)
+}
+
+func (x *_StakeAuthorization_Validators_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_StakeAuthorization_Validators         protoreflect.MessageDescriptor
+	fd_StakeAuthorization_Validators_address protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_authz_proto_init()
+	md_StakeAuthorization_Validators = File_cosmos_staking_v1beta1_authz_proto.Messages().ByName("StakeAuthorization").Messages().ByName("Validators")
+	fd_StakeAuthorization_Validators_address = md_StakeAuthorization_Validators.Fields().ByName("address")
+}
+
+var _ protoreflect.Message = (*fastReflection_StakeAuthorization_Validators)(nil)
+
+type fastReflection_StakeAuthorization_Validators StakeAuthorization_Validators
+
+func (x *StakeAuthorization_Validators) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_StakeAuthorization_Validators)(x)
+}
+
+func (x *StakeAuthorization_Validators) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_authz_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_StakeAuthorization_Validators_messageType fastReflection_StakeAuthorization_Validators_messageType
+var _ protoreflect.MessageType = fastReflection_StakeAuthorization_Validators_messageType{}
+
+type fastReflection_StakeAuthorization_Validators_messageType struct{}
+
+func (x fastReflection_StakeAuthorization_Validators_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_StakeAuthorization_Validators)(nil)
+}
+func (x fastReflection_StakeAuthorization_Validators_messageType) New() protoreflect.Message {
+	return new(fastReflection_StakeAuthorization_Validators)
+}
+func (x fastReflection_StakeAuthorization_Validators_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_StakeAuthorization_Validators
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_StakeAuthorization_Validators) Descriptor() protoreflect.MessageDescriptor {
+	return md_StakeAuthorization_Validators
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_StakeAuthorization_Validators) Type() protoreflect.MessageType {
+	return _fastReflection_StakeAuthorization_Validators_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_StakeAuthorization_Validators) New() protoreflect.Message {
+	return new(fastReflection_StakeAuthorization_Validators)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_StakeAuthorization_Validators) Interface() protoreflect.ProtoMessage {
+	return (*StakeAuthorization_Validators)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_StakeAuthorization_Validators) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Address) != 0 {
+		value := protoreflect.ValueOfList(&_StakeAuthorization_Validators_1_list{list: &x.Address})
+		if !f(fd_StakeAuthorization_Validators_address, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_StakeAuthorization_Validators) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.Validators.address":
+		return len(x.Address) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization.Validators"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization.Validators does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_StakeAuthorization_Validators) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.Validators.address":
+		x.Address = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization.Validators"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization.Validators does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_StakeAuthorization_Validators) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.Validators.address":
+		if len(x.Address) == 0 {
+			return protoreflect.ValueOfList(&_StakeAuthorization_Validators_1_list{})
+		}
+		listValue := &_StakeAuthorization_Validators_1_list{list: &x.Address}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization.Validators"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization.Validators does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_StakeAuthorization_Validators) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.Validators.address":
+		lv := value.List()
+		clv := lv.(*_StakeAuthorization_Validators_1_list)
+		x.Address = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization.Validators"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization.Validators does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_StakeAuthorization_Validators) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.Validators.address":
+		if x.Address == nil {
+			x.Address = []string{}
+		}
+		value := &_StakeAuthorization_Validators_1_list{list: &x.Address}
+		return protoreflect.ValueOfList(value)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization.Validators"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization.Validators does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_StakeAuthorization_Validators) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.StakeAuthorization.Validators.address":
+		list := []string{}
+		return protoreflect.ValueOfList(&_StakeAuthorization_Validators_1_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.StakeAuthorization.Validators"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.StakeAuthorization.Validators does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_StakeAuthorization_Validators) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.StakeAuthorization.Validators", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_StakeAuthorization_Validators) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_StakeAuthorization_Validators) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_StakeAuthorization_Validators) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_StakeAuthorization_Validators) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*StakeAuthorization_Validators)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.Address) > 0 {
+			for _, s := range x.Address {
+				l = len(s)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*StakeAuthorization_Validators)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Address) > 0 {
+			for iNdEx := len(x.Address) - 1; iNdEx >= 0; iNdEx-- {
+				i -= len(x.Address[iNdEx])
+				copy(dAtA[i:], x.Address[iNdEx])
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address[iNdEx])))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*StakeAuthorization_Validators)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: StakeAuthorization_Validators: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: StakeAuthorization_Validators: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Address = append(x.Address, string(dAtA[iNdEx:postIndex]))
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.0
+// 	protoc        (unknown)
+// source: cosmos/staking/v1beta1/authz.proto
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// AuthorizationType defines the type of staking module authorization type
+//
+// Since: cosmos-sdk 0.43
+type AuthorizationType int32
+
+const (
+	// AUTHORIZATION_TYPE_UNSPECIFIED specifies an unknown authorization type
+	AuthorizationType_AUTHORIZATION_TYPE_UNSPECIFIED AuthorizationType = 0
+	// AUTHORIZATION_TYPE_DELEGATE defines an authorization type for Msg/Delegate
+	AuthorizationType_AUTHORIZATION_TYPE_DELEGATE AuthorizationType = 1
+	// AUTHORIZATION_TYPE_UNDELEGATE defines an authorization type for Msg/Undelegate
+	AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE AuthorizationType = 2
+	// AUTHORIZATION_TYPE_REDELEGATE defines an authorization type for Msg/BeginRedelegate
+	AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE AuthorizationType = 3
+	// AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION defines an authorization type for Msg/MsgCancelUnbondingDelegation
+	AuthorizationType_AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION AuthorizationType = 4
+)
+
+// Enum value maps for AuthorizationType.
+var (
+	AuthorizationType_name = map[int32]string{
+		0: "AUTHORIZATION_TYPE_UNSPECIFIED",
+		1: "AUTHORIZATION_TYPE_DELEGATE",
+		2: "AUTHORIZATION_TYPE_UNDELEGATE",
+		3: "AUTHORIZATION_TYPE_REDELEGATE",
+		4: "AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION",
+	}
+	AuthorizationType_value = map[string]int32{
+		"AUTHORIZATION_TYPE_UNSPECIFIED":                 0,
+		"AUTHORIZATION_TYPE_DELEGATE":                    1,
+		"AUTHORIZATION_TYPE_UNDELEGATE":                  2,
+		"AUTHORIZATION_TYPE_REDELEGATE":                  3,
+		"AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION": 4,
+	}
+)
+
+func (x AuthorizationType) Enum() *AuthorizationType {
+	p := new(AuthorizationType)
+	*p = x
+	return p
+}
+
+func (x AuthorizationType) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (AuthorizationType) Descriptor() protoreflect.EnumDescriptor {
+	return file_cosmos_staking_v1beta1_authz_proto_enumTypes[0].Descriptor()
+}
+
+func (AuthorizationType) Type() protoreflect.EnumType {
+	return &file_cosmos_staking_v1beta1_authz_proto_enumTypes[0]
+}
+
+func (x AuthorizationType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use AuthorizationType.Descriptor instead.
+func (AuthorizationType) EnumDescriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_authz_proto_rawDescGZIP(), []int{0}
+}
+
+// StakeAuthorization defines authorization for delegate/undelegate/redelegate.
+//
+// Since: cosmos-sdk 0.43
+type StakeAuthorization struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// max_tokens specifies the maximum amount of tokens can be delegate to a validator. If it is
+	// empty, there is no spend limit and any amount of coins can be delegated.
+	MaxTokens *v1beta1.Coin `protobuf:"bytes,1,opt,name=max_tokens,json=maxTokens,proto3" json:"max_tokens,omitempty"`
+	// validators is the oneof that represents either allow_list or deny_list
+	//
+	// Types that are assignable to Validators:
+	//
+	//	*StakeAuthorization_AllowList
+	//	*StakeAuthorization_DenyList
+	Validators isStakeAuthorization_Validators `protobuf_oneof:"validators"`
+	// authorization_type defines one of AuthorizationType.
+	AuthorizationType AuthorizationType `protobuf:"varint,4,opt,name=authorization_type,json=authorizationType,proto3,enum=cosmos.staking.v1beta1.AuthorizationType" json:"authorization_type,omitempty"`
+}
+
+func (x *StakeAuthorization) Reset() {
+	*x = StakeAuthorization{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_authz_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *StakeAuthorization) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StakeAuthorization) ProtoMessage() {}
+
+// Deprecated: Use StakeAuthorization.ProtoReflect.Descriptor instead.
+func (*StakeAuthorization) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_authz_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *StakeAuthorization) GetMaxTokens() *v1beta1.Coin {
+	if x != nil {
+		return x.MaxTokens
+	}
+	return nil
+}
+
+func (x *StakeAuthorization) GetValidators() isStakeAuthorization_Validators {
+	if x != nil {
+		return x.Validators
+	}
+	return nil
+}
+
+func (x *StakeAuthorization) GetAllowList() *StakeAuthorization_Validators {
+	if x, ok := x.GetValidators().(*StakeAuthorization_AllowList); ok {
+		return x.AllowList
+	}
+	return nil
+}
+
+func (x *StakeAuthorization) GetDenyList() *StakeAuthorization_Validators {
+	if x, ok := x.GetValidators().(*StakeAuthorization_DenyList); ok {
+		return x.DenyList
+	}
+	return nil
+}
+
+func (x *StakeAuthorization) GetAuthorizationType() AuthorizationType {
+	if x != nil {
+		return x.AuthorizationType
+	}
+	return AuthorizationType_AUTHORIZATION_TYPE_UNSPECIFIED
+}
+
+type isStakeAuthorization_Validators interface {
+	isStakeAuthorization_Validators()
+}
+
+type StakeAuthorization_AllowList struct {
+	// allow_list specifies list of validator addresses to whom grantee can delegate tokens on behalf of granter's
+	// account.
+	AllowList *StakeAuthorization_Validators `protobuf:"bytes,2,opt,name=allow_list,json=allowList,proto3,oneof"`
+}
+
+type StakeAuthorization_DenyList struct {
+	// deny_list specifies list of validator addresses to whom grantee can not delegate tokens.
+	DenyList *StakeAuthorization_Validators `protobuf:"bytes,3,opt,name=deny_list,json=denyList,proto3,oneof"`
+}
+
+func (*StakeAuthorization_AllowList) isStakeAuthorization_Validators() {}
+
+func (*StakeAuthorization_DenyList) isStakeAuthorization_Validators() {}
+
+// Validators defines list of validator addresses.
+type StakeAuthorization_Validators struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Address []string `protobuf:"bytes,1,rep,name=address,proto3" json:"address,omitempty"`
+}
+
+func (x *StakeAuthorization_Validators) Reset() {
+	*x = StakeAuthorization_Validators{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_authz_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *StakeAuthorization_Validators) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StakeAuthorization_Validators) ProtoMessage() {}
+
+// Deprecated: Use StakeAuthorization_Validators.ProtoReflect.Descriptor instead.
+func (*StakeAuthorization_Validators) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_authz_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *StakeAuthorization_Validators) GetAddress() []string {
+	if x != nil {
+		return x.Address
+	}
+	return nil
+}
+
+var File_cosmos_staking_v1beta1_authz_proto protoreflect.FileDescriptor
+
+var file_cosmos_staking_v1beta1_authz_proto_rawDesc = []byte{
+	0x0a, 0x22, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x7a, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x1a, 0x14, 0x67, 0x6f,
+	0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0x2f, 0x63, 0x6f, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x11, 0x61,
+	0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x22, 0xfa, 0x04, 0x0a, 0x12, 0x53, 0x74, 0x61, 0x6b, 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72,
+	0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x65, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x74,
+	0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x2b, 0xaa, 0xdf, 0x1f, 0x27, 0x67, 0x69, 0x74, 0x68,
+	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x43,
+	0x6f, 0x69, 0x6e, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x84,
+	0x01, 0x0a, 0x0a, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x74, 0x61,
+	0x6b, 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x42, 0x2c, 0xb2, 0xe7, 0xb0, 0x2a,
+	0x27, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x53, 0x74, 0x61, 0x6b,
+	0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x41,
+	0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x48, 0x00, 0x52, 0x09, 0x61, 0x6c, 0x6c, 0x6f,
+	0x77, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x81, 0x01, 0x0a, 0x09, 0x64, 0x65, 0x6e, 0x79, 0x5f, 0x6c,
+	0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x6b, 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73,
+	0x42, 0x2b, 0xb2, 0xe7, 0xb0, 0x2a, 0x26, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64,
+	0x6b, 0x2f, 0x53, 0x74, 0x61, 0x6b, 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x44, 0x65, 0x6e, 0x79, 0x4c, 0x69, 0x73, 0x74, 0x48, 0x00, 0x52,
+	0x08, 0x64, 0x65, 0x6e, 0x79, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x58, 0x0a, 0x12, 0x61, 0x75, 0x74,
+	0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x41,
+	0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65,
+	0x52, 0x11, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54,
+	0x79, 0x70, 0x65, 0x1a, 0x40, 0x0a, 0x0a, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x73, 0x12, 0x32, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x07, 0x61, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x48, 0xca, 0xb4, 0x2d, 0x22, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x7a, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e,
+	0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x8a, 0xe7, 0xb0,
+	0x2a, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x53, 0x74, 0x61,
+	0x6b, 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42,
+	0x0c, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x2a, 0xd2, 0x01,
+	0x0a, 0x11, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54,
+	0x79, 0x70, 0x65, 0x12, 0x22, 0x0a, 0x1e, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41,
+	0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43,
+	0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1f, 0x0a, 0x1b, 0x41, 0x55, 0x54, 0x48, 0x4f,
+	0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x45,
+	0x4c, 0x45, 0x47, 0x41, 0x54, 0x45, 0x10, 0x01, 0x12, 0x21, 0x0a, 0x1d, 0x41, 0x55, 0x54, 0x48,
+	0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55,
+	0x4e, 0x44, 0x45, 0x4c, 0x45, 0x47, 0x41, 0x54, 0x45, 0x10, 0x02, 0x12, 0x21, 0x0a, 0x1d, 0x41,
+	0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50,
+	0x45, 0x5f, 0x52, 0x45, 0x44, 0x45, 0x4c, 0x45, 0x47, 0x41, 0x54, 0x45, 0x10, 0x03, 0x12, 0x32,
+	0x0a, 0x2e, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f,
+	0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x55, 0x4e, 0x42, 0x4f,
+	0x4e, 0x44, 0x49, 0x4e, 0x47, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x47, 0x41, 0x54, 0x49, 0x4f, 0x4e,
+	0x10, 0x04, 0x42, 0xda, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x42, 0x0a, 0x41, 0x75, 0x74, 0x68, 0x7a, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a,
+	0x36, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70,
+	0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x53, 0x58, 0xaa, 0x02, 0x16,
+	0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x56,
+	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, 0x02, 0x16, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c,
+	0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2,
+	0x02, 0x22, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61,
+	0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x18, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x53,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x62,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cosmos_staking_v1beta1_authz_proto_rawDescOnce sync.Once
+	file_cosmos_staking_v1beta1_authz_proto_rawDescData = file_cosmos_staking_v1beta1_authz_proto_rawDesc
+)
+
+func file_cosmos_staking_v1beta1_authz_proto_rawDescGZIP() []byte {
+	file_cosmos_staking_v1beta1_authz_proto_rawDescOnce.Do(func() {
+		file_cosmos_staking_v1beta1_authz_proto_rawDescData = protoimpl.X.CompressGZIP(file_cosmos_staking_v1beta1_authz_proto_rawDescData)
+	})
+	return file_cosmos_staking_v1beta1_authz_proto_rawDescData
+}
+
+var file_cosmos_staking_v1beta1_authz_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_cosmos_staking_v1beta1_authz_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_cosmos_staking_v1beta1_authz_proto_goTypes = []interface{}{
+	(AuthorizationType)(0),                // 0: cosmos.staking.v1beta1.AuthorizationType
+	(*StakeAuthorization)(nil),            // 1: cosmos.staking.v1beta1.StakeAuthorization
+	(*StakeAuthorization_Validators)(nil), // 2: cosmos.staking.v1beta1.StakeAuthorization.Validators
+	(*v1beta1.Coin)(nil),                  // 3: cosmos.base.v1beta1.Coin
+}
+var file_cosmos_staking_v1beta1_authz_proto_depIdxs = []int32{
+	3, // 0: cosmos.staking.v1beta1.StakeAuthorization.max_tokens:type_name -> cosmos.base.v1beta1.Coin
+	2, // 1: cosmos.staking.v1beta1.StakeAuthorization.allow_list:type_name -> cosmos.staking.v1beta1.StakeAuthorization.Validators
+	2, // 2: cosmos.staking.v1beta1.StakeAuthorization.deny_list:type_name -> cosmos.staking.v1beta1.StakeAuthorization.Validators
+	0, // 3: cosmos.staking.v1beta1.StakeAuthorization.authorization_type:type_name -> cosmos.staking.v1beta1.AuthorizationType
+	4, // [4:4] is the sub-list for method output_type
+	4, // [4:4] is the sub-list for method input_type
+	4, // [4:4] is the sub-list for extension type_name
+	4, // [4:4] is the sub-list for extension extendee
+	0, // [0:4] is the sub-list for field type_name
+}
+
+func init() { file_cosmos_staking_v1beta1_authz_proto_init() }
+func file_cosmos_staking_v1beta1_authz_proto_init() {
+	if File_cosmos_staking_v1beta1_authz_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cosmos_staking_v1beta1_authz_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*StakeAuthorization); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_authz_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*StakeAuthorization_Validators); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_cosmos_staking_v1beta1_authz_proto_msgTypes[0].OneofWrappers = []interface{}{
+		(*StakeAuthorization_AllowList)(nil),
+		(*StakeAuthorization_DenyList)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cosmos_staking_v1beta1_authz_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cosmos_staking_v1beta1_authz_proto_goTypes,
+		DependencyIndexes: file_cosmos_staking_v1beta1_authz_proto_depIdxs,
+		EnumInfos:         file_cosmos_staking_v1beta1_authz_proto_enumTypes,
+		MessageInfos:      file_cosmos_staking_v1beta1_authz_proto_msgTypes,
+	}.Build()
+	File_cosmos_staking_v1beta1_authz_proto = out.File
+	file_cosmos_staking_v1beta1_authz_proto_rawDesc = nil
+	file_cosmos_staking_v1beta1_authz_proto_goTypes = nil
+	file_cosmos_staking_v1beta1_authz_proto_depIdxs = nil
+}
diff --git a/atomone-api/cosmos/staking/v1beta1/genesis.pulsar.go b/atomone-api/cosmos/staking/v1beta1/genesis.pulsar.go
new file mode 100644
index 000000000000..09c705bdb2e7
--- /dev/null
+++ b/atomone-api/cosmos/staking/v1beta1/genesis.pulsar.go
@@ -0,0 +1,2057 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package stakingv1beta1
+
+import (
+	_ "cosmossdk.io/api/amino"
+	fmt "fmt"
+	_ "github.com/cosmos/cosmos-proto"
+	runtime "github.com/cosmos/cosmos-proto/runtime"
+	_ "github.com/cosmos/gogoproto/gogoproto"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	io "io"
+	reflect "reflect"
+	sync "sync"
+)
+
+var _ protoreflect.List = (*_GenesisState_3_list)(nil)
+
+type _GenesisState_3_list struct {
+	list *[]*LastValidatorPower
+}
+
+func (x *_GenesisState_3_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_GenesisState_3_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GenesisState_3_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*LastValidatorPower)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisState_3_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*LastValidatorPower)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisState_3_list) AppendMutable() protoreflect.Value {
+	v := new(LastValidatorPower)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_3_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisState_3_list) NewElement() protoreflect.Value {
+	v := new(LastValidatorPower)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_3_list) IsValid() bool {
+	return x.list != nil
+}
+
+var _ protoreflect.List = (*_GenesisState_4_list)(nil)
+
+type _GenesisState_4_list struct {
+	list *[]*Validator
+}
+
+func (x *_GenesisState_4_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_GenesisState_4_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GenesisState_4_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Validator)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisState_4_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Validator)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisState_4_list) AppendMutable() protoreflect.Value {
+	v := new(Validator)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_4_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisState_4_list) NewElement() protoreflect.Value {
+	v := new(Validator)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_4_list) IsValid() bool {
+	return x.list != nil
+}
+
+var _ protoreflect.List = (*_GenesisState_5_list)(nil)
+
+type _GenesisState_5_list struct {
+	list *[]*Delegation
+}
+
+func (x *_GenesisState_5_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_GenesisState_5_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GenesisState_5_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Delegation)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisState_5_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Delegation)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisState_5_list) AppendMutable() protoreflect.Value {
+	v := new(Delegation)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_5_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisState_5_list) NewElement() protoreflect.Value {
+	v := new(Delegation)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_5_list) IsValid() bool {
+	return x.list != nil
+}
+
+var _ protoreflect.List = (*_GenesisState_6_list)(nil)
+
+type _GenesisState_6_list struct {
+	list *[]*UnbondingDelegation
+}
+
+func (x *_GenesisState_6_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_GenesisState_6_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GenesisState_6_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*UnbondingDelegation)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisState_6_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*UnbondingDelegation)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisState_6_list) AppendMutable() protoreflect.Value {
+	v := new(UnbondingDelegation)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_6_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisState_6_list) NewElement() protoreflect.Value {
+	v := new(UnbondingDelegation)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_6_list) IsValid() bool {
+	return x.list != nil
+}
+
+var _ protoreflect.List = (*_GenesisState_7_list)(nil)
+
+type _GenesisState_7_list struct {
+	list *[]*Redelegation
+}
+
+func (x *_GenesisState_7_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_GenesisState_7_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_GenesisState_7_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Redelegation)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_GenesisState_7_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Redelegation)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_GenesisState_7_list) AppendMutable() protoreflect.Value {
+	v := new(Redelegation)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_7_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_GenesisState_7_list) NewElement() protoreflect.Value {
+	v := new(Redelegation)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_GenesisState_7_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_GenesisState                       protoreflect.MessageDescriptor
+	fd_GenesisState_params                protoreflect.FieldDescriptor
+	fd_GenesisState_last_total_power      protoreflect.FieldDescriptor
+	fd_GenesisState_last_validator_powers protoreflect.FieldDescriptor
+	fd_GenesisState_validators            protoreflect.FieldDescriptor
+	fd_GenesisState_delegations           protoreflect.FieldDescriptor
+	fd_GenesisState_unbonding_delegations protoreflect.FieldDescriptor
+	fd_GenesisState_redelegations         protoreflect.FieldDescriptor
+	fd_GenesisState_exported              protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_genesis_proto_init()
+	md_GenesisState = File_cosmos_staking_v1beta1_genesis_proto.Messages().ByName("GenesisState")
+	fd_GenesisState_params = md_GenesisState.Fields().ByName("params")
+	fd_GenesisState_last_total_power = md_GenesisState.Fields().ByName("last_total_power")
+	fd_GenesisState_last_validator_powers = md_GenesisState.Fields().ByName("last_validator_powers")
+	fd_GenesisState_validators = md_GenesisState.Fields().ByName("validators")
+	fd_GenesisState_delegations = md_GenesisState.Fields().ByName("delegations")
+	fd_GenesisState_unbonding_delegations = md_GenesisState.Fields().ByName("unbonding_delegations")
+	fd_GenesisState_redelegations = md_GenesisState.Fields().ByName("redelegations")
+	fd_GenesisState_exported = md_GenesisState.Fields().ByName("exported")
+}
+
+var _ protoreflect.Message = (*fastReflection_GenesisState)(nil)
+
+type fastReflection_GenesisState GenesisState
+
+func (x *GenesisState) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_GenesisState)(x)
+}
+
+func (x *GenesisState) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_genesis_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_GenesisState_messageType fastReflection_GenesisState_messageType
+var _ protoreflect.MessageType = fastReflection_GenesisState_messageType{}
+
+type fastReflection_GenesisState_messageType struct{}
+
+func (x fastReflection_GenesisState_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_GenesisState)(nil)
+}
+func (x fastReflection_GenesisState_messageType) New() protoreflect.Message {
+	return new(fastReflection_GenesisState)
+}
+func (x fastReflection_GenesisState_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_GenesisState
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_GenesisState) Descriptor() protoreflect.MessageDescriptor {
+	return md_GenesisState
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_GenesisState) Type() protoreflect.MessageType {
+	return _fastReflection_GenesisState_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_GenesisState) New() protoreflect.Message {
+	return new(fastReflection_GenesisState)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_GenesisState) Interface() protoreflect.ProtoMessage {
+	return (*GenesisState)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_GenesisState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Params != nil {
+		value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+		if !f(fd_GenesisState_params, value) {
+			return
+		}
+	}
+	if len(x.LastTotalPower) != 0 {
+		value := protoreflect.ValueOfBytes(x.LastTotalPower)
+		if !f(fd_GenesisState_last_total_power, value) {
+			return
+		}
+	}
+	if len(x.LastValidatorPowers) != 0 {
+		value := protoreflect.ValueOfList(&_GenesisState_3_list{list: &x.LastValidatorPowers})
+		if !f(fd_GenesisState_last_validator_powers, value) {
+			return
+		}
+	}
+	if len(x.Validators) != 0 {
+		value := protoreflect.ValueOfList(&_GenesisState_4_list{list: &x.Validators})
+		if !f(fd_GenesisState_validators, value) {
+			return
+		}
+	}
+	if len(x.Delegations) != 0 {
+		value := protoreflect.ValueOfList(&_GenesisState_5_list{list: &x.Delegations})
+		if !f(fd_GenesisState_delegations, value) {
+			return
+		}
+	}
+	if len(x.UnbondingDelegations) != 0 {
+		value := protoreflect.ValueOfList(&_GenesisState_6_list{list: &x.UnbondingDelegations})
+		if !f(fd_GenesisState_unbonding_delegations, value) {
+			return
+		}
+	}
+	if len(x.Redelegations) != 0 {
+		value := protoreflect.ValueOfList(&_GenesisState_7_list{list: &x.Redelegations})
+		if !f(fd_GenesisState_redelegations, value) {
+			return
+		}
+	}
+	if x.Exported != false {
+		value := protoreflect.ValueOfBool(x.Exported)
+		if !f(fd_GenesisState_exported, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_GenesisState) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.GenesisState.params":
+		return x.Params != nil
+	case "cosmos.staking.v1beta1.GenesisState.last_total_power":
+		return len(x.LastTotalPower) != 0
+	case "cosmos.staking.v1beta1.GenesisState.last_validator_powers":
+		return len(x.LastValidatorPowers) != 0
+	case "cosmos.staking.v1beta1.GenesisState.validators":
+		return len(x.Validators) != 0
+	case "cosmos.staking.v1beta1.GenesisState.delegations":
+		return len(x.Delegations) != 0
+	case "cosmos.staking.v1beta1.GenesisState.unbonding_delegations":
+		return len(x.UnbondingDelegations) != 0
+	case "cosmos.staking.v1beta1.GenesisState.redelegations":
+		return len(x.Redelegations) != 0
+	case "cosmos.staking.v1beta1.GenesisState.exported":
+		return x.Exported != false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.GenesisState"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.GenesisState does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_GenesisState) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.GenesisState.params":
+		x.Params = nil
+	case "cosmos.staking.v1beta1.GenesisState.last_total_power":
+		x.LastTotalPower = nil
+	case "cosmos.staking.v1beta1.GenesisState.last_validator_powers":
+		x.LastValidatorPowers = nil
+	case "cosmos.staking.v1beta1.GenesisState.validators":
+		x.Validators = nil
+	case "cosmos.staking.v1beta1.GenesisState.delegations":
+		x.Delegations = nil
+	case "cosmos.staking.v1beta1.GenesisState.unbonding_delegations":
+		x.UnbondingDelegations = nil
+	case "cosmos.staking.v1beta1.GenesisState.redelegations":
+		x.Redelegations = nil
+	case "cosmos.staking.v1beta1.GenesisState.exported":
+		x.Exported = false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.GenesisState"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.GenesisState does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_GenesisState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.GenesisState.params":
+		value := x.Params
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.GenesisState.last_total_power":
+		value := x.LastTotalPower
+		return protoreflect.ValueOfBytes(value)
+	case "cosmos.staking.v1beta1.GenesisState.last_validator_powers":
+		if len(x.LastValidatorPowers) == 0 {
+			return protoreflect.ValueOfList(&_GenesisState_3_list{})
+		}
+		listValue := &_GenesisState_3_list{list: &x.LastValidatorPowers}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.GenesisState.validators":
+		if len(x.Validators) == 0 {
+			return protoreflect.ValueOfList(&_GenesisState_4_list{})
+		}
+		listValue := &_GenesisState_4_list{list: &x.Validators}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.GenesisState.delegations":
+		if len(x.Delegations) == 0 {
+			return protoreflect.ValueOfList(&_GenesisState_5_list{})
+		}
+		listValue := &_GenesisState_5_list{list: &x.Delegations}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.GenesisState.unbonding_delegations":
+		if len(x.UnbondingDelegations) == 0 {
+			return protoreflect.ValueOfList(&_GenesisState_6_list{})
+		}
+		listValue := &_GenesisState_6_list{list: &x.UnbondingDelegations}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.GenesisState.redelegations":
+		if len(x.Redelegations) == 0 {
+			return protoreflect.ValueOfList(&_GenesisState_7_list{})
+		}
+		listValue := &_GenesisState_7_list{list: &x.Redelegations}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.GenesisState.exported":
+		value := x.Exported
+		return protoreflect.ValueOfBool(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.GenesisState"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.GenesisState does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_GenesisState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.GenesisState.params":
+		x.Params = value.Message().Interface().(*Params)
+	case "cosmos.staking.v1beta1.GenesisState.last_total_power":
+		x.LastTotalPower = value.Bytes()
+	case "cosmos.staking.v1beta1.GenesisState.last_validator_powers":
+		lv := value.List()
+		clv := lv.(*_GenesisState_3_list)
+		x.LastValidatorPowers = *clv.list
+	case "cosmos.staking.v1beta1.GenesisState.validators":
+		lv := value.List()
+		clv := lv.(*_GenesisState_4_list)
+		x.Validators = *clv.list
+	case "cosmos.staking.v1beta1.GenesisState.delegations":
+		lv := value.List()
+		clv := lv.(*_GenesisState_5_list)
+		x.Delegations = *clv.list
+	case "cosmos.staking.v1beta1.GenesisState.unbonding_delegations":
+		lv := value.List()
+		clv := lv.(*_GenesisState_6_list)
+		x.UnbondingDelegations = *clv.list
+	case "cosmos.staking.v1beta1.GenesisState.redelegations":
+		lv := value.List()
+		clv := lv.(*_GenesisState_7_list)
+		x.Redelegations = *clv.list
+	case "cosmos.staking.v1beta1.GenesisState.exported":
+		x.Exported = value.Bool()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.GenesisState"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.GenesisState does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_GenesisState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.GenesisState.params":
+		if x.Params == nil {
+			x.Params = new(Params)
+		}
+		return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+	case "cosmos.staking.v1beta1.GenesisState.last_validator_powers":
+		if x.LastValidatorPowers == nil {
+			x.LastValidatorPowers = []*LastValidatorPower{}
+		}
+		value := &_GenesisState_3_list{list: &x.LastValidatorPowers}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.GenesisState.validators":
+		if x.Validators == nil {
+			x.Validators = []*Validator{}
+		}
+		value := &_GenesisState_4_list{list: &x.Validators}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.GenesisState.delegations":
+		if x.Delegations == nil {
+			x.Delegations = []*Delegation{}
+		}
+		value := &_GenesisState_5_list{list: &x.Delegations}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.GenesisState.unbonding_delegations":
+		if x.UnbondingDelegations == nil {
+			x.UnbondingDelegations = []*UnbondingDelegation{}
+		}
+		value := &_GenesisState_6_list{list: &x.UnbondingDelegations}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.GenesisState.redelegations":
+		if x.Redelegations == nil {
+			x.Redelegations = []*Redelegation{}
+		}
+		value := &_GenesisState_7_list{list: &x.Redelegations}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.GenesisState.last_total_power":
+		panic(fmt.Errorf("field last_total_power of message cosmos.staking.v1beta1.GenesisState is not mutable"))
+	case "cosmos.staking.v1beta1.GenesisState.exported":
+		panic(fmt.Errorf("field exported of message cosmos.staking.v1beta1.GenesisState is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.GenesisState"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.GenesisState does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_GenesisState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.GenesisState.params":
+		m := new(Params)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.GenesisState.last_total_power":
+		return protoreflect.ValueOfBytes(nil)
+	case "cosmos.staking.v1beta1.GenesisState.last_validator_powers":
+		list := []*LastValidatorPower{}
+		return protoreflect.ValueOfList(&_GenesisState_3_list{list: &list})
+	case "cosmos.staking.v1beta1.GenesisState.validators":
+		list := []*Validator{}
+		return protoreflect.ValueOfList(&_GenesisState_4_list{list: &list})
+	case "cosmos.staking.v1beta1.GenesisState.delegations":
+		list := []*Delegation{}
+		return protoreflect.ValueOfList(&_GenesisState_5_list{list: &list})
+	case "cosmos.staking.v1beta1.GenesisState.unbonding_delegations":
+		list := []*UnbondingDelegation{}
+		return protoreflect.ValueOfList(&_GenesisState_6_list{list: &list})
+	case "cosmos.staking.v1beta1.GenesisState.redelegations":
+		list := []*Redelegation{}
+		return protoreflect.ValueOfList(&_GenesisState_7_list{list: &list})
+	case "cosmos.staking.v1beta1.GenesisState.exported":
+		return protoreflect.ValueOfBool(false)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.GenesisState"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.GenesisState does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_GenesisState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.GenesisState", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_GenesisState) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_GenesisState) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_GenesisState) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_GenesisState) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*GenesisState)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Params != nil {
+			l = options.Size(x.Params)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.LastTotalPower)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.LastValidatorPowers) > 0 {
+			for _, e := range x.LastValidatorPowers {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if len(x.Validators) > 0 {
+			for _, e := range x.Validators {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if len(x.Delegations) > 0 {
+			for _, e := range x.Delegations {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if len(x.UnbondingDelegations) > 0 {
+			for _, e := range x.UnbondingDelegations {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if len(x.Redelegations) > 0 {
+			for _, e := range x.Redelegations {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Exported {
+			n += 2
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*GenesisState)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Exported {
+			i--
+			if x.Exported {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x40
+		}
+		if len(x.Redelegations) > 0 {
+			for iNdEx := len(x.Redelegations) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Redelegations[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x3a
+			}
+		}
+		if len(x.UnbondingDelegations) > 0 {
+			for iNdEx := len(x.UnbondingDelegations) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.UnbondingDelegations[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x32
+			}
+		}
+		if len(x.Delegations) > 0 {
+			for iNdEx := len(x.Delegations) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Delegations[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x2a
+			}
+		}
+		if len(x.Validators) > 0 {
+			for iNdEx := len(x.Validators) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Validators[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x22
+			}
+		}
+		if len(x.LastValidatorPowers) > 0 {
+			for iNdEx := len(x.LastValidatorPowers) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.LastValidatorPowers[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x1a
+			}
+		}
+		if len(x.LastTotalPower) > 0 {
+			i -= len(x.LastTotalPower)
+			copy(dAtA[i:], x.LastTotalPower)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.LastTotalPower)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.Params != nil {
+			encoded, err := options.Marshal(x.Params)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*GenesisState)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Params == nil {
+					x.Params = &Params{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Params); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LastTotalPower", wireType)
+				}
+				var byteLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					byteLen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if byteLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + byteLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.LastTotalPower = append(x.LastTotalPower[:0], dAtA[iNdEx:postIndex]...)
+				if x.LastTotalPower == nil {
+					x.LastTotalPower = []byte{}
+				}
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LastValidatorPowers", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.LastValidatorPowers = append(x.LastValidatorPowers, &LastValidatorPower{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.LastValidatorPowers[len(x.LastValidatorPowers)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Validators = append(x.Validators, &Validator{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Validators[len(x.Validators)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Delegations", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Delegations = append(x.Delegations, &Delegation{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Delegations[len(x.Delegations)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 6:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingDelegations", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.UnbondingDelegations = append(x.UnbondingDelegations, &UnbondingDelegation{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.UnbondingDelegations[len(x.UnbondingDelegations)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 7:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Redelegations", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Redelegations = append(x.Redelegations, &Redelegation{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Redelegations[len(x.Redelegations)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 8:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Exported", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.Exported = bool(v != 0)
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_LastValidatorPower         protoreflect.MessageDescriptor
+	fd_LastValidatorPower_address protoreflect.FieldDescriptor
+	fd_LastValidatorPower_power   protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_genesis_proto_init()
+	md_LastValidatorPower = File_cosmos_staking_v1beta1_genesis_proto.Messages().ByName("LastValidatorPower")
+	fd_LastValidatorPower_address = md_LastValidatorPower.Fields().ByName("address")
+	fd_LastValidatorPower_power = md_LastValidatorPower.Fields().ByName("power")
+}
+
+var _ protoreflect.Message = (*fastReflection_LastValidatorPower)(nil)
+
+type fastReflection_LastValidatorPower LastValidatorPower
+
+func (x *LastValidatorPower) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_LastValidatorPower)(x)
+}
+
+func (x *LastValidatorPower) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_genesis_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_LastValidatorPower_messageType fastReflection_LastValidatorPower_messageType
+var _ protoreflect.MessageType = fastReflection_LastValidatorPower_messageType{}
+
+type fastReflection_LastValidatorPower_messageType struct{}
+
+func (x fastReflection_LastValidatorPower_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_LastValidatorPower)(nil)
+}
+func (x fastReflection_LastValidatorPower_messageType) New() protoreflect.Message {
+	return new(fastReflection_LastValidatorPower)
+}
+func (x fastReflection_LastValidatorPower_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_LastValidatorPower
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_LastValidatorPower) Descriptor() protoreflect.MessageDescriptor {
+	return md_LastValidatorPower
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_LastValidatorPower) Type() protoreflect.MessageType {
+	return _fastReflection_LastValidatorPower_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_LastValidatorPower) New() protoreflect.Message {
+	return new(fastReflection_LastValidatorPower)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_LastValidatorPower) Interface() protoreflect.ProtoMessage {
+	return (*LastValidatorPower)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_LastValidatorPower) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Address != "" {
+		value := protoreflect.ValueOfString(x.Address)
+		if !f(fd_LastValidatorPower_address, value) {
+			return
+		}
+	}
+	if x.Power != int64(0) {
+		value := protoreflect.ValueOfInt64(x.Power)
+		if !f(fd_LastValidatorPower_power, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_LastValidatorPower) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.LastValidatorPower.address":
+		return x.Address != ""
+	case "cosmos.staking.v1beta1.LastValidatorPower.power":
+		return x.Power != int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.LastValidatorPower"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.LastValidatorPower does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_LastValidatorPower) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.LastValidatorPower.address":
+		x.Address = ""
+	case "cosmos.staking.v1beta1.LastValidatorPower.power":
+		x.Power = int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.LastValidatorPower"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.LastValidatorPower does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_LastValidatorPower) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.LastValidatorPower.address":
+		value := x.Address
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.LastValidatorPower.power":
+		value := x.Power
+		return protoreflect.ValueOfInt64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.LastValidatorPower"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.LastValidatorPower does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_LastValidatorPower) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.LastValidatorPower.address":
+		x.Address = value.Interface().(string)
+	case "cosmos.staking.v1beta1.LastValidatorPower.power":
+		x.Power = value.Int()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.LastValidatorPower"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.LastValidatorPower does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_LastValidatorPower) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.LastValidatorPower.address":
+		panic(fmt.Errorf("field address of message cosmos.staking.v1beta1.LastValidatorPower is not mutable"))
+	case "cosmos.staking.v1beta1.LastValidatorPower.power":
+		panic(fmt.Errorf("field power of message cosmos.staking.v1beta1.LastValidatorPower is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.LastValidatorPower"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.LastValidatorPower does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_LastValidatorPower) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.LastValidatorPower.address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.LastValidatorPower.power":
+		return protoreflect.ValueOfInt64(int64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.LastValidatorPower"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.LastValidatorPower does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_LastValidatorPower) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.LastValidatorPower", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_LastValidatorPower) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_LastValidatorPower) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_LastValidatorPower) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_LastValidatorPower) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*LastValidatorPower)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Address)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Power != 0 {
+			n += 1 + runtime.Sov(uint64(x.Power))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*LastValidatorPower)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Power != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Power))
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.Address) > 0 {
+			i -= len(x.Address)
+			copy(dAtA[i:], x.Address)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*LastValidatorPower)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: LastValidatorPower: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: LastValidatorPower: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Address = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
+				}
+				x.Power = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Power |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.0
+// 	protoc        (unknown)
+// source: cosmos/staking/v1beta1/genesis.proto
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// GenesisState defines the staking module's genesis state.
+type GenesisState struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// params defines all the parameters of related to deposit.
+	Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
+	// last_total_power tracks the total amounts of bonded tokens recorded during
+	// the previous end block.
+	LastTotalPower []byte `protobuf:"bytes,2,opt,name=last_total_power,json=lastTotalPower,proto3" json:"last_total_power,omitempty"`
+	// last_validator_powers is a special index that provides a historical list
+	// of the last-block's bonded validators.
+	LastValidatorPowers []*LastValidatorPower `protobuf:"bytes,3,rep,name=last_validator_powers,json=lastValidatorPowers,proto3" json:"last_validator_powers,omitempty"`
+	// validators defines the validator set at genesis.
+	Validators []*Validator `protobuf:"bytes,4,rep,name=validators,proto3" json:"validators,omitempty"`
+	// delegations defines the delegations active at genesis.
+	Delegations []*Delegation `protobuf:"bytes,5,rep,name=delegations,proto3" json:"delegations,omitempty"`
+	// unbonding_delegations defines the unbonding delegations active at genesis.
+	UnbondingDelegations []*UnbondingDelegation `protobuf:"bytes,6,rep,name=unbonding_delegations,json=unbondingDelegations,proto3" json:"unbonding_delegations,omitempty"`
+	// redelegations defines the redelegations active at genesis.
+	Redelegations []*Redelegation `protobuf:"bytes,7,rep,name=redelegations,proto3" json:"redelegations,omitempty"`
+	// exported defines a bool to identify whether the chain dealing with exported or initialized genesis.
+	Exported bool `protobuf:"varint,8,opt,name=exported,proto3" json:"exported,omitempty"`
+}
+
+func (x *GenesisState) Reset() {
+	*x = GenesisState{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_genesis_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GenesisState) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GenesisState) ProtoMessage() {}
+
+// Deprecated: Use GenesisState.ProtoReflect.Descriptor instead.
+func (*GenesisState) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_genesis_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GenesisState) GetParams() *Params {
+	if x != nil {
+		return x.Params
+	}
+	return nil
+}
+
+func (x *GenesisState) GetLastTotalPower() []byte {
+	if x != nil {
+		return x.LastTotalPower
+	}
+	return nil
+}
+
+func (x *GenesisState) GetLastValidatorPowers() []*LastValidatorPower {
+	if x != nil {
+		return x.LastValidatorPowers
+	}
+	return nil
+}
+
+func (x *GenesisState) GetValidators() []*Validator {
+	if x != nil {
+		return x.Validators
+	}
+	return nil
+}
+
+func (x *GenesisState) GetDelegations() []*Delegation {
+	if x != nil {
+		return x.Delegations
+	}
+	return nil
+}
+
+func (x *GenesisState) GetUnbondingDelegations() []*UnbondingDelegation {
+	if x != nil {
+		return x.UnbondingDelegations
+	}
+	return nil
+}
+
+func (x *GenesisState) GetRedelegations() []*Redelegation {
+	if x != nil {
+		return x.Redelegations
+	}
+	return nil
+}
+
+func (x *GenesisState) GetExported() bool {
+	if x != nil {
+		return x.Exported
+	}
+	return false
+}
+
+// LastValidatorPower required for validator set update logic.
+type LastValidatorPower struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// address is the address of the validator.
+	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+	// power defines the power of the validator.
+	Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"`
+}
+
+func (x *LastValidatorPower) Reset() {
+	*x = LastValidatorPower{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_genesis_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *LastValidatorPower) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LastValidatorPower) ProtoMessage() {}
+
+// Deprecated: Use LastValidatorPower.ProtoReflect.Descriptor instead.
+func (*LastValidatorPower) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_genesis_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *LastValidatorPower) GetAddress() string {
+	if x != nil {
+		return x.Address
+	}
+	return ""
+}
+
+func (x *LastValidatorPower) GetPower() int64 {
+	if x != nil {
+		return x.Power
+	}
+	return 0
+}
+
+var File_cosmos_staking_v1beta1_genesis_proto protoreflect.FileDescriptor
+
+var file_cosmos_staking_v1beta1_genesis_proto_rawDesc = []byte{
+	0x0a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x1a, 0x14,
+	0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69,
+	0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x97, 0x05, 0x0a, 0x0c, 0x47, 0x65, 0x6e,
+	0x65, 0x73, 0x69, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x41, 0x0a, 0x06, 0x70, 0x61, 0x72,
+	0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8,
+	0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x5a, 0x0a, 0x10,
+	0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x30, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x15,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74,
+	0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x49, 0x6e, 0x74, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0e, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x6f,
+	0x74, 0x61, 0x6c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x12, 0x69, 0x0a, 0x15, 0x6c, 0x61, 0x73, 0x74,
+	0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72,
+	0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x4c, 0x61, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x6f,
+	0x77, 0x65, 0x72, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x13,
+	0x6c, 0x61, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x6f, 0x77,
+	0x65, 0x72, 0x73, 0x12, 0x4c, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00,
+	0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x73, 0x12, 0x4f, 0x0a, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e,
+	0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00,
+	0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x12, 0x6b, 0x0a, 0x15, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f,
+	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x2b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69,
+	0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x55, 0x6e, 0x62, 0x6f, 0x6e,
+	0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09,
+	0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x14, 0x75, 0x6e, 0x62, 0x6f, 0x6e,
+	0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12,
+	0x55, 0x0a, 0x0d, 0x72, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e,
+	0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde,
+	0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0d, 0x72, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74,
+	0x65, 0x64, 0x22, 0x68, 0x0a, 0x12, 0x4c, 0x61, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x12, 0x32, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x14, 0x0a, 0x05,
+	0x70, 0x6f, 0x77, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x70, 0x6f, 0x77,
+	0x65, 0x72, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x42, 0xdc, 0x01, 0x0a,
+	0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b,
+	0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x42, 0x0c, 0x47, 0x65, 0x6e,
+	0x65, 0x73, 0x69, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x36, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0x3b, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x76, 0x31, 0x62, 0x65,
+	0x74, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x53, 0x58, 0xaa, 0x02, 0x16, 0x43, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x56, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0xca, 0x02, 0x16, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x74, 0x61, 0x6b,
+	0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, 0x22, 0x43, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+	0xea, 0x02, 0x18, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x53, 0x74, 0x61, 0x6b, 0x69,
+	0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cosmos_staking_v1beta1_genesis_proto_rawDescOnce sync.Once
+	file_cosmos_staking_v1beta1_genesis_proto_rawDescData = file_cosmos_staking_v1beta1_genesis_proto_rawDesc
+)
+
+func file_cosmos_staking_v1beta1_genesis_proto_rawDescGZIP() []byte {
+	file_cosmos_staking_v1beta1_genesis_proto_rawDescOnce.Do(func() {
+		file_cosmos_staking_v1beta1_genesis_proto_rawDescData = protoimpl.X.CompressGZIP(file_cosmos_staking_v1beta1_genesis_proto_rawDescData)
+	})
+	return file_cosmos_staking_v1beta1_genesis_proto_rawDescData
+}
+
+var file_cosmos_staking_v1beta1_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_cosmos_staking_v1beta1_genesis_proto_goTypes = []interface{}{
+	(*GenesisState)(nil),        // 0: cosmos.staking.v1beta1.GenesisState
+	(*LastValidatorPower)(nil),  // 1: cosmos.staking.v1beta1.LastValidatorPower
+	(*Params)(nil),              // 2: cosmos.staking.v1beta1.Params
+	(*Validator)(nil),           // 3: cosmos.staking.v1beta1.Validator
+	(*Delegation)(nil),          // 4: cosmos.staking.v1beta1.Delegation
+	(*UnbondingDelegation)(nil), // 5: cosmos.staking.v1beta1.UnbondingDelegation
+	(*Redelegation)(nil),        // 6: cosmos.staking.v1beta1.Redelegation
+}
+var file_cosmos_staking_v1beta1_genesis_proto_depIdxs = []int32{
+	2, // 0: cosmos.staking.v1beta1.GenesisState.params:type_name -> cosmos.staking.v1beta1.Params
+	1, // 1: cosmos.staking.v1beta1.GenesisState.last_validator_powers:type_name -> cosmos.staking.v1beta1.LastValidatorPower
+	3, // 2: cosmos.staking.v1beta1.GenesisState.validators:type_name -> cosmos.staking.v1beta1.Validator
+	4, // 3: cosmos.staking.v1beta1.GenesisState.delegations:type_name -> cosmos.staking.v1beta1.Delegation
+	5, // 4: cosmos.staking.v1beta1.GenesisState.unbonding_delegations:type_name -> cosmos.staking.v1beta1.UnbondingDelegation
+	6, // 5: cosmos.staking.v1beta1.GenesisState.redelegations:type_name -> cosmos.staking.v1beta1.Redelegation
+	6, // [6:6] is the sub-list for method output_type
+	6, // [6:6] is the sub-list for method input_type
+	6, // [6:6] is the sub-list for extension type_name
+	6, // [6:6] is the sub-list for extension extendee
+	0, // [0:6] is the sub-list for field type_name
+}
+
+func init() { file_cosmos_staking_v1beta1_genesis_proto_init() }
+func file_cosmos_staking_v1beta1_genesis_proto_init() {
+	if File_cosmos_staking_v1beta1_genesis_proto != nil {
+		return
+	}
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_cosmos_staking_v1beta1_genesis_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GenesisState); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_genesis_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*LastValidatorPower); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cosmos_staking_v1beta1_genesis_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cosmos_staking_v1beta1_genesis_proto_goTypes,
+		DependencyIndexes: file_cosmos_staking_v1beta1_genesis_proto_depIdxs,
+		MessageInfos:      file_cosmos_staking_v1beta1_genesis_proto_msgTypes,
+	}.Build()
+	File_cosmos_staking_v1beta1_genesis_proto = out.File
+	file_cosmos_staking_v1beta1_genesis_proto_rawDesc = nil
+	file_cosmos_staking_v1beta1_genesis_proto_goTypes = nil
+	file_cosmos_staking_v1beta1_genesis_proto_depIdxs = nil
+}
diff --git a/atomone-api/cosmos/staking/v1beta1/query.pulsar.go b/atomone-api/cosmos/staking/v1beta1/query.pulsar.go
new file mode 100644
index 000000000000..f0538f036791
--- /dev/null
+++ b/atomone-api/cosmos/staking/v1beta1/query.pulsar.go
@@ -0,0 +1,15865 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package stakingv1beta1
+
+import (
+	_ "cosmossdk.io/api/amino"
+	v1beta1 "cosmossdk.io/api/cosmos/base/query/v1beta1"
+	_ "cosmossdk.io/api/cosmos/query/v1"
+	fmt "fmt"
+	_ "github.com/cosmos/cosmos-proto"
+	runtime "github.com/cosmos/cosmos-proto/runtime"
+	_ "github.com/cosmos/gogoproto/gogoproto"
+	_ "google.golang.org/genproto/googleapis/api/annotations"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	io "io"
+	reflect "reflect"
+	sync "sync"
+)
+
+var (
+	md_QueryValidatorsRequest            protoreflect.MessageDescriptor
+	fd_QueryValidatorsRequest_status     protoreflect.FieldDescriptor
+	fd_QueryValidatorsRequest_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryValidatorsRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryValidatorsRequest")
+	fd_QueryValidatorsRequest_status = md_QueryValidatorsRequest.Fields().ByName("status")
+	fd_QueryValidatorsRequest_pagination = md_QueryValidatorsRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryValidatorsRequest)(nil)
+
+type fastReflection_QueryValidatorsRequest QueryValidatorsRequest
+
+func (x *QueryValidatorsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidatorsRequest)(x)
+}
+
+func (x *QueryValidatorsRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryValidatorsRequest_messageType fastReflection_QueryValidatorsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidatorsRequest_messageType{}
+
+type fastReflection_QueryValidatorsRequest_messageType struct{}
+
+func (x fastReflection_QueryValidatorsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidatorsRequest)(nil)
+}
+func (x fastReflection_QueryValidatorsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorsRequest)
+}
+func (x fastReflection_QueryValidatorsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryValidatorsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorsRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryValidatorsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidatorsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryValidatorsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryValidatorsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidatorsRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryValidatorsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Status != "" {
+		value := protoreflect.ValueOfString(x.Status)
+		if !f(fd_QueryValidatorsRequest_status, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryValidatorsRequest_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryValidatorsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.status":
+		return x.Status != ""
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorsRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.status":
+		x.Status = ""
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryValidatorsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.status":
+		value := x.Status
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.status":
+		x.Status = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.status":
+		panic(fmt.Errorf("field status of message cosmos.staking.v1beta1.QueryValidatorsRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryValidatorsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.status":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryValidatorsRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryValidatorsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryValidatorsRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryValidatorsRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorsRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryValidatorsRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryValidatorsRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryValidatorsRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Status)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorsRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.Status) > 0 {
+			i -= len(x.Status)
+			copy(dAtA[i:], x.Status)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Status)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorsRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorsRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Status = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_QueryValidatorsResponse_1_list)(nil)
+
+type _QueryValidatorsResponse_1_list struct {
+	list *[]*Validator
+}
+
+func (x *_QueryValidatorsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryValidatorsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryValidatorsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Validator)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryValidatorsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Validator)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryValidatorsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(Validator)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryValidatorsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryValidatorsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(Validator)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryValidatorsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryValidatorsResponse            protoreflect.MessageDescriptor
+	fd_QueryValidatorsResponse_validators protoreflect.FieldDescriptor
+	fd_QueryValidatorsResponse_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryValidatorsResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryValidatorsResponse")
+	fd_QueryValidatorsResponse_validators = md_QueryValidatorsResponse.Fields().ByName("validators")
+	fd_QueryValidatorsResponse_pagination = md_QueryValidatorsResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryValidatorsResponse)(nil)
+
+type fastReflection_QueryValidatorsResponse QueryValidatorsResponse
+
+func (x *QueryValidatorsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidatorsResponse)(x)
+}
+
+func (x *QueryValidatorsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryValidatorsResponse_messageType fastReflection_QueryValidatorsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidatorsResponse_messageType{}
+
+type fastReflection_QueryValidatorsResponse_messageType struct{}
+
+func (x fastReflection_QueryValidatorsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidatorsResponse)(nil)
+}
+func (x fastReflection_QueryValidatorsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorsResponse)
+}
+func (x fastReflection_QueryValidatorsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryValidatorsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorsResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryValidatorsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidatorsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryValidatorsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryValidatorsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidatorsResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryValidatorsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Validators) != 0 {
+		value := protoreflect.ValueOfList(&_QueryValidatorsResponse_1_list{list: &x.Validators})
+		if !f(fd_QueryValidatorsResponse_validators, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryValidatorsResponse_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryValidatorsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.validators":
+		return len(x.Validators) != 0
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorsResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.validators":
+		x.Validators = nil
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryValidatorsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.validators":
+		if len(x.Validators) == 0 {
+			return protoreflect.ValueOfList(&_QueryValidatorsResponse_1_list{})
+		}
+		listValue := &_QueryValidatorsResponse_1_list{list: &x.Validators}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.validators":
+		lv := value.List()
+		clv := lv.(*_QueryValidatorsResponse_1_list)
+		x.Validators = *clv.list
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.validators":
+		if x.Validators == nil {
+			x.Validators = []*Validator{}
+		}
+		value := &_QueryValidatorsResponse_1_list{list: &x.Validators}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryValidatorsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.validators":
+		list := []*Validator{}
+		return protoreflect.ValueOfList(&_QueryValidatorsResponse_1_list{list: &list})
+	case "cosmos.staking.v1beta1.QueryValidatorsResponse.pagination":
+		m := new(v1beta1.PageResponse)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryValidatorsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryValidatorsResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryValidatorsResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorsResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryValidatorsResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryValidatorsResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryValidatorsResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.Validators) > 0 {
+			for _, e := range x.Validators {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorsResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.Validators) > 0 {
+			for iNdEx := len(x.Validators) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Validators[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorsResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorsResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Validators = append(x.Validators, &Validator{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Validators[len(x.Validators)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryValidatorRequest                protoreflect.MessageDescriptor
+	fd_QueryValidatorRequest_validator_addr protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryValidatorRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryValidatorRequest")
+	fd_QueryValidatorRequest_validator_addr = md_QueryValidatorRequest.Fields().ByName("validator_addr")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryValidatorRequest)(nil)
+
+type fastReflection_QueryValidatorRequest QueryValidatorRequest
+
+func (x *QueryValidatorRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidatorRequest)(x)
+}
+
+func (x *QueryValidatorRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryValidatorRequest_messageType fastReflection_QueryValidatorRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidatorRequest_messageType{}
+
+type fastReflection_QueryValidatorRequest_messageType struct{}
+
+func (x fastReflection_QueryValidatorRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidatorRequest)(nil)
+}
+func (x fastReflection_QueryValidatorRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorRequest)
+}
+func (x fastReflection_QueryValidatorRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryValidatorRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryValidatorRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidatorRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryValidatorRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryValidatorRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidatorRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryValidatorRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ValidatorAddr != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddr)
+		if !f(fd_QueryValidatorRequest_validator_addr, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryValidatorRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorRequest.validator_addr":
+		return x.ValidatorAddr != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorRequest.validator_addr":
+		x.ValidatorAddr = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryValidatorRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorRequest.validator_addr":
+		value := x.ValidatorAddr
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorRequest.validator_addr":
+		x.ValidatorAddr = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorRequest.validator_addr":
+		panic(fmt.Errorf("field validator_addr of message cosmos.staking.v1beta1.QueryValidatorRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryValidatorRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorRequest.validator_addr":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryValidatorRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryValidatorRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryValidatorRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryValidatorRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryValidatorRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryValidatorRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.ValidatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.ValidatorAddr) > 0 {
+			i -= len(x.ValidatorAddr)
+			copy(dAtA[i:], x.ValidatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddr)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryValidatorResponse           protoreflect.MessageDescriptor
+	fd_QueryValidatorResponse_validator protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryValidatorResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryValidatorResponse")
+	fd_QueryValidatorResponse_validator = md_QueryValidatorResponse.Fields().ByName("validator")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryValidatorResponse)(nil)
+
+type fastReflection_QueryValidatorResponse QueryValidatorResponse
+
+func (x *QueryValidatorResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidatorResponse)(x)
+}
+
+func (x *QueryValidatorResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryValidatorResponse_messageType fastReflection_QueryValidatorResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidatorResponse_messageType{}
+
+type fastReflection_QueryValidatorResponse_messageType struct{}
+
+func (x fastReflection_QueryValidatorResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidatorResponse)(nil)
+}
+func (x fastReflection_QueryValidatorResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorResponse)
+}
+func (x fastReflection_QueryValidatorResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryValidatorResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryValidatorResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidatorResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryValidatorResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryValidatorResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidatorResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryValidatorResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Validator != nil {
+		value := protoreflect.ValueOfMessage(x.Validator.ProtoReflect())
+		if !f(fd_QueryValidatorResponse_validator, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryValidatorResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorResponse.validator":
+		return x.Validator != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorResponse.validator":
+		x.Validator = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryValidatorResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorResponse.validator":
+		value := x.Validator
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorResponse.validator":
+		x.Validator = value.Message().Interface().(*Validator)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorResponse.validator":
+		if x.Validator == nil {
+			x.Validator = new(Validator)
+		}
+		return protoreflect.ValueOfMessage(x.Validator.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryValidatorResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorResponse.validator":
+		m := new(Validator)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryValidatorResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryValidatorResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryValidatorResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryValidatorResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryValidatorResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryValidatorResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Validator != nil {
+			l = options.Size(x.Validator)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Validator != nil {
+			encoded, err := options.Marshal(x.Validator)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Validator == nil {
+					x.Validator = &Validator{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Validator); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryValidatorDelegationsRequest                protoreflect.MessageDescriptor
+	fd_QueryValidatorDelegationsRequest_validator_addr protoreflect.FieldDescriptor
+	fd_QueryValidatorDelegationsRequest_pagination     protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryValidatorDelegationsRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryValidatorDelegationsRequest")
+	fd_QueryValidatorDelegationsRequest_validator_addr = md_QueryValidatorDelegationsRequest.Fields().ByName("validator_addr")
+	fd_QueryValidatorDelegationsRequest_pagination = md_QueryValidatorDelegationsRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryValidatorDelegationsRequest)(nil)
+
+type fastReflection_QueryValidatorDelegationsRequest QueryValidatorDelegationsRequest
+
+func (x *QueryValidatorDelegationsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidatorDelegationsRequest)(x)
+}
+
+func (x *QueryValidatorDelegationsRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryValidatorDelegationsRequest_messageType fastReflection_QueryValidatorDelegationsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidatorDelegationsRequest_messageType{}
+
+type fastReflection_QueryValidatorDelegationsRequest_messageType struct{}
+
+func (x fastReflection_QueryValidatorDelegationsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidatorDelegationsRequest)(nil)
+}
+func (x fastReflection_QueryValidatorDelegationsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorDelegationsRequest)
+}
+func (x fastReflection_QueryValidatorDelegationsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorDelegationsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryValidatorDelegationsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorDelegationsRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryValidatorDelegationsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidatorDelegationsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryValidatorDelegationsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorDelegationsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryValidatorDelegationsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidatorDelegationsRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryValidatorDelegationsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ValidatorAddr != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddr)
+		if !f(fd_QueryValidatorDelegationsRequest_validator_addr, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryValidatorDelegationsRequest_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryValidatorDelegationsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.validator_addr":
+		return x.ValidatorAddr != ""
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorDelegationsRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.validator_addr":
+		x.ValidatorAddr = ""
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryValidatorDelegationsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.validator_addr":
+		value := x.ValidatorAddr
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorDelegationsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.validator_addr":
+		x.ValidatorAddr = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorDelegationsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.validator_addr":
+		panic(fmt.Errorf("field validator_addr of message cosmos.staking.v1beta1.QueryValidatorDelegationsRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryValidatorDelegationsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.validator_addr":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryValidatorDelegationsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryValidatorDelegationsRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryValidatorDelegationsRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorDelegationsRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryValidatorDelegationsRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryValidatorDelegationsRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryValidatorDelegationsRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.ValidatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorDelegationsRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.ValidatorAddr) > 0 {
+			i -= len(x.ValidatorAddr)
+			copy(dAtA[i:], x.ValidatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddr)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorDelegationsRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorDelegationsRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorDelegationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_QueryValidatorDelegationsResponse_1_list)(nil)
+
+type _QueryValidatorDelegationsResponse_1_list struct {
+	list *[]*DelegationResponse
+}
+
+func (x *_QueryValidatorDelegationsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryValidatorDelegationsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryValidatorDelegationsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DelegationResponse)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryValidatorDelegationsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DelegationResponse)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryValidatorDelegationsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(DelegationResponse)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryValidatorDelegationsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryValidatorDelegationsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(DelegationResponse)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryValidatorDelegationsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryValidatorDelegationsResponse                      protoreflect.MessageDescriptor
+	fd_QueryValidatorDelegationsResponse_delegation_responses protoreflect.FieldDescriptor
+	fd_QueryValidatorDelegationsResponse_pagination           protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryValidatorDelegationsResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryValidatorDelegationsResponse")
+	fd_QueryValidatorDelegationsResponse_delegation_responses = md_QueryValidatorDelegationsResponse.Fields().ByName("delegation_responses")
+	fd_QueryValidatorDelegationsResponse_pagination = md_QueryValidatorDelegationsResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryValidatorDelegationsResponse)(nil)
+
+type fastReflection_QueryValidatorDelegationsResponse QueryValidatorDelegationsResponse
+
+func (x *QueryValidatorDelegationsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidatorDelegationsResponse)(x)
+}
+
+func (x *QueryValidatorDelegationsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryValidatorDelegationsResponse_messageType fastReflection_QueryValidatorDelegationsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidatorDelegationsResponse_messageType{}
+
+type fastReflection_QueryValidatorDelegationsResponse_messageType struct{}
+
+func (x fastReflection_QueryValidatorDelegationsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidatorDelegationsResponse)(nil)
+}
+func (x fastReflection_QueryValidatorDelegationsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorDelegationsResponse)
+}
+func (x fastReflection_QueryValidatorDelegationsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorDelegationsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryValidatorDelegationsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorDelegationsResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryValidatorDelegationsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidatorDelegationsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryValidatorDelegationsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorDelegationsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryValidatorDelegationsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidatorDelegationsResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryValidatorDelegationsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.DelegationResponses) != 0 {
+		value := protoreflect.ValueOfList(&_QueryValidatorDelegationsResponse_1_list{list: &x.DelegationResponses})
+		if !f(fd_QueryValidatorDelegationsResponse_delegation_responses, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryValidatorDelegationsResponse_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryValidatorDelegationsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.delegation_responses":
+		return len(x.DelegationResponses) != 0
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorDelegationsResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.delegation_responses":
+		x.DelegationResponses = nil
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryValidatorDelegationsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.delegation_responses":
+		if len(x.DelegationResponses) == 0 {
+			return protoreflect.ValueOfList(&_QueryValidatorDelegationsResponse_1_list{})
+		}
+		listValue := &_QueryValidatorDelegationsResponse_1_list{list: &x.DelegationResponses}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorDelegationsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.delegation_responses":
+		lv := value.List()
+		clv := lv.(*_QueryValidatorDelegationsResponse_1_list)
+		x.DelegationResponses = *clv.list
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorDelegationsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.delegation_responses":
+		if x.DelegationResponses == nil {
+			x.DelegationResponses = []*DelegationResponse{}
+		}
+		value := &_QueryValidatorDelegationsResponse_1_list{list: &x.DelegationResponses}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryValidatorDelegationsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.delegation_responses":
+		list := []*DelegationResponse{}
+		return protoreflect.ValueOfList(&_QueryValidatorDelegationsResponse_1_list{list: &list})
+	case "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.pagination":
+		m := new(v1beta1.PageResponse)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryValidatorDelegationsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryValidatorDelegationsResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryValidatorDelegationsResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorDelegationsResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryValidatorDelegationsResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryValidatorDelegationsResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryValidatorDelegationsResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.DelegationResponses) > 0 {
+			for _, e := range x.DelegationResponses {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorDelegationsResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegationResponses) > 0 {
+			for iNdEx := len(x.DelegationResponses) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.DelegationResponses[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorDelegationsResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorDelegationsResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorDelegationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegationResponses", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegationResponses = append(x.DelegationResponses, &DelegationResponse{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DelegationResponses[len(x.DelegationResponses)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryValidatorUnbondingDelegationsRequest                protoreflect.MessageDescriptor
+	fd_QueryValidatorUnbondingDelegationsRequest_validator_addr protoreflect.FieldDescriptor
+	fd_QueryValidatorUnbondingDelegationsRequest_pagination     protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryValidatorUnbondingDelegationsRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryValidatorUnbondingDelegationsRequest")
+	fd_QueryValidatorUnbondingDelegationsRequest_validator_addr = md_QueryValidatorUnbondingDelegationsRequest.Fields().ByName("validator_addr")
+	fd_QueryValidatorUnbondingDelegationsRequest_pagination = md_QueryValidatorUnbondingDelegationsRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryValidatorUnbondingDelegationsRequest)(nil)
+
+type fastReflection_QueryValidatorUnbondingDelegationsRequest QueryValidatorUnbondingDelegationsRequest
+
+func (x *QueryValidatorUnbondingDelegationsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidatorUnbondingDelegationsRequest)(x)
+}
+
+func (x *QueryValidatorUnbondingDelegationsRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryValidatorUnbondingDelegationsRequest_messageType fastReflection_QueryValidatorUnbondingDelegationsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidatorUnbondingDelegationsRequest_messageType{}
+
+type fastReflection_QueryValidatorUnbondingDelegationsRequest_messageType struct{}
+
+func (x fastReflection_QueryValidatorUnbondingDelegationsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidatorUnbondingDelegationsRequest)(nil)
+}
+func (x fastReflection_QueryValidatorUnbondingDelegationsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorUnbondingDelegationsRequest)
+}
+func (x fastReflection_QueryValidatorUnbondingDelegationsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorUnbondingDelegationsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorUnbondingDelegationsRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidatorUnbondingDelegationsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorUnbondingDelegationsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidatorUnbondingDelegationsRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ValidatorAddr != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddr)
+		if !f(fd_QueryValidatorUnbondingDelegationsRequest_validator_addr, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryValidatorUnbondingDelegationsRequest_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.validator_addr":
+		return x.ValidatorAddr != ""
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.validator_addr":
+		x.ValidatorAddr = ""
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.validator_addr":
+		value := x.ValidatorAddr
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.validator_addr":
+		x.ValidatorAddr = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.validator_addr":
+		panic(fmt.Errorf("field validator_addr of message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.validator_addr":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryValidatorUnbondingDelegationsRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.ValidatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorUnbondingDelegationsRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.ValidatorAddr) > 0 {
+			i -= len(x.ValidatorAddr)
+			copy(dAtA[i:], x.ValidatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddr)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorUnbondingDelegationsRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorUnbondingDelegationsRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorUnbondingDelegationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_QueryValidatorUnbondingDelegationsResponse_1_list)(nil)
+
+type _QueryValidatorUnbondingDelegationsResponse_1_list struct {
+	list *[]*UnbondingDelegation
+}
+
+func (x *_QueryValidatorUnbondingDelegationsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryValidatorUnbondingDelegationsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryValidatorUnbondingDelegationsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*UnbondingDelegation)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryValidatorUnbondingDelegationsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*UnbondingDelegation)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryValidatorUnbondingDelegationsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(UnbondingDelegation)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryValidatorUnbondingDelegationsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryValidatorUnbondingDelegationsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(UnbondingDelegation)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryValidatorUnbondingDelegationsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryValidatorUnbondingDelegationsResponse                     protoreflect.MessageDescriptor
+	fd_QueryValidatorUnbondingDelegationsResponse_unbonding_responses protoreflect.FieldDescriptor
+	fd_QueryValidatorUnbondingDelegationsResponse_pagination          protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryValidatorUnbondingDelegationsResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryValidatorUnbondingDelegationsResponse")
+	fd_QueryValidatorUnbondingDelegationsResponse_unbonding_responses = md_QueryValidatorUnbondingDelegationsResponse.Fields().ByName("unbonding_responses")
+	fd_QueryValidatorUnbondingDelegationsResponse_pagination = md_QueryValidatorUnbondingDelegationsResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryValidatorUnbondingDelegationsResponse)(nil)
+
+type fastReflection_QueryValidatorUnbondingDelegationsResponse QueryValidatorUnbondingDelegationsResponse
+
+func (x *QueryValidatorUnbondingDelegationsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidatorUnbondingDelegationsResponse)(x)
+}
+
+func (x *QueryValidatorUnbondingDelegationsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryValidatorUnbondingDelegationsResponse_messageType fastReflection_QueryValidatorUnbondingDelegationsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidatorUnbondingDelegationsResponse_messageType{}
+
+type fastReflection_QueryValidatorUnbondingDelegationsResponse_messageType struct{}
+
+func (x fastReflection_QueryValidatorUnbondingDelegationsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidatorUnbondingDelegationsResponse)(nil)
+}
+func (x fastReflection_QueryValidatorUnbondingDelegationsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorUnbondingDelegationsResponse)
+}
+func (x fastReflection_QueryValidatorUnbondingDelegationsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorUnbondingDelegationsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidatorUnbondingDelegationsResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidatorUnbondingDelegationsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryValidatorUnbondingDelegationsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidatorUnbondingDelegationsResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.UnbondingResponses) != 0 {
+		value := protoreflect.ValueOfList(&_QueryValidatorUnbondingDelegationsResponse_1_list{list: &x.UnbondingResponses})
+		if !f(fd_QueryValidatorUnbondingDelegationsResponse_unbonding_responses, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryValidatorUnbondingDelegationsResponse_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.unbonding_responses":
+		return len(x.UnbondingResponses) != 0
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.unbonding_responses":
+		x.UnbondingResponses = nil
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.unbonding_responses":
+		if len(x.UnbondingResponses) == 0 {
+			return protoreflect.ValueOfList(&_QueryValidatorUnbondingDelegationsResponse_1_list{})
+		}
+		listValue := &_QueryValidatorUnbondingDelegationsResponse_1_list{list: &x.UnbondingResponses}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.unbonding_responses":
+		lv := value.List()
+		clv := lv.(*_QueryValidatorUnbondingDelegationsResponse_1_list)
+		x.UnbondingResponses = *clv.list
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.unbonding_responses":
+		if x.UnbondingResponses == nil {
+			x.UnbondingResponses = []*UnbondingDelegation{}
+		}
+		value := &_QueryValidatorUnbondingDelegationsResponse_1_list{list: &x.UnbondingResponses}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.unbonding_responses":
+		list := []*UnbondingDelegation{}
+		return protoreflect.ValueOfList(&_QueryValidatorUnbondingDelegationsResponse_1_list{list: &list})
+	case "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.pagination":
+		m := new(v1beta1.PageResponse)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryValidatorUnbondingDelegationsResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryValidatorUnbondingDelegationsResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.UnbondingResponses) > 0 {
+			for _, e := range x.UnbondingResponses {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorUnbondingDelegationsResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.UnbondingResponses) > 0 {
+			for iNdEx := len(x.UnbondingResponses) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.UnbondingResponses[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryValidatorUnbondingDelegationsResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorUnbondingDelegationsResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidatorUnbondingDelegationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingResponses", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.UnbondingResponses = append(x.UnbondingResponses, &UnbondingDelegation{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.UnbondingResponses[len(x.UnbondingResponses)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryDelegationRequest                protoreflect.MessageDescriptor
+	fd_QueryDelegationRequest_delegator_addr protoreflect.FieldDescriptor
+	fd_QueryDelegationRequest_validator_addr protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryDelegationRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryDelegationRequest")
+	fd_QueryDelegationRequest_delegator_addr = md_QueryDelegationRequest.Fields().ByName("delegator_addr")
+	fd_QueryDelegationRequest_validator_addr = md_QueryDelegationRequest.Fields().ByName("validator_addr")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDelegationRequest)(nil)
+
+type fastReflection_QueryDelegationRequest QueryDelegationRequest
+
+func (x *QueryDelegationRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDelegationRequest)(x)
+}
+
+func (x *QueryDelegationRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryDelegationRequest_messageType fastReflection_QueryDelegationRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDelegationRequest_messageType{}
+
+type fastReflection_QueryDelegationRequest_messageType struct{}
+
+func (x fastReflection_QueryDelegationRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDelegationRequest)(nil)
+}
+func (x fastReflection_QueryDelegationRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegationRequest)
+}
+func (x fastReflection_QueryDelegationRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegationRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryDelegationRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegationRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryDelegationRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDelegationRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryDelegationRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegationRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryDelegationRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryDelegationRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryDelegationRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddr != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddr)
+		if !f(fd_QueryDelegationRequest_delegator_addr, value) {
+			return
+		}
+	}
+	if x.ValidatorAddr != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddr)
+		if !f(fd_QueryDelegationRequest_validator_addr, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryDelegationRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.delegator_addr":
+		return x.DelegatorAddr != ""
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.validator_addr":
+		return x.ValidatorAddr != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegationRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.delegator_addr":
+		x.DelegatorAddr = ""
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.validator_addr":
+		x.ValidatorAddr = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryDelegationRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.delegator_addr":
+		value := x.DelegatorAddr
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.validator_addr":
+		value := x.ValidatorAddr
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegationRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.delegator_addr":
+		x.DelegatorAddr = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.validator_addr":
+		x.ValidatorAddr = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegationRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.delegator_addr":
+		panic(fmt.Errorf("field delegator_addr of message cosmos.staking.v1beta1.QueryDelegationRequest is not mutable"))
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.validator_addr":
+		panic(fmt.Errorf("field validator_addr of message cosmos.staking.v1beta1.QueryDelegationRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryDelegationRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.delegator_addr":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryDelegationRequest.validator_addr":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryDelegationRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryDelegationRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryDelegationRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegationRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryDelegationRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryDelegationRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryDelegationRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegationRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.ValidatorAddr) > 0 {
+			i -= len(x.ValidatorAddr)
+			copy(dAtA[i:], x.ValidatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddr)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddr) > 0 {
+			i -= len(x.DelegatorAddr)
+			copy(dAtA[i:], x.DelegatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddr)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegationRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegationRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryDelegationResponse                     protoreflect.MessageDescriptor
+	fd_QueryDelegationResponse_delegation_response protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryDelegationResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryDelegationResponse")
+	fd_QueryDelegationResponse_delegation_response = md_QueryDelegationResponse.Fields().ByName("delegation_response")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDelegationResponse)(nil)
+
+type fastReflection_QueryDelegationResponse QueryDelegationResponse
+
+func (x *QueryDelegationResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDelegationResponse)(x)
+}
+
+func (x *QueryDelegationResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryDelegationResponse_messageType fastReflection_QueryDelegationResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDelegationResponse_messageType{}
+
+type fastReflection_QueryDelegationResponse_messageType struct{}
+
+func (x fastReflection_QueryDelegationResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDelegationResponse)(nil)
+}
+func (x fastReflection_QueryDelegationResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegationResponse)
+}
+func (x fastReflection_QueryDelegationResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegationResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryDelegationResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegationResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryDelegationResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDelegationResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryDelegationResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegationResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryDelegationResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryDelegationResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryDelegationResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegationResponse != nil {
+		value := protoreflect.ValueOfMessage(x.DelegationResponse.ProtoReflect())
+		if !f(fd_QueryDelegationResponse_delegation_response, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryDelegationResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationResponse.delegation_response":
+		return x.DelegationResponse != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegationResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationResponse.delegation_response":
+		x.DelegationResponse = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryDelegationResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationResponse.delegation_response":
+		value := x.DelegationResponse
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegationResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationResponse.delegation_response":
+		x.DelegationResponse = value.Message().Interface().(*DelegationResponse)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegationResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationResponse.delegation_response":
+		if x.DelegationResponse == nil {
+			x.DelegationResponse = new(DelegationResponse)
+		}
+		return protoreflect.ValueOfMessage(x.DelegationResponse.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryDelegationResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegationResponse.delegation_response":
+		m := new(DelegationResponse)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryDelegationResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryDelegationResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryDelegationResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegationResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryDelegationResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryDelegationResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryDelegationResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.DelegationResponse != nil {
+			l = options.Size(x.DelegationResponse)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegationResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.DelegationResponse != nil {
+			encoded, err := options.Marshal(x.DelegationResponse)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegationResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegationResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegationResponse", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.DelegationResponse == nil {
+					x.DelegationResponse = &DelegationResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DelegationResponse); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryUnbondingDelegationRequest                protoreflect.MessageDescriptor
+	fd_QueryUnbondingDelegationRequest_delegator_addr protoreflect.FieldDescriptor
+	fd_QueryUnbondingDelegationRequest_validator_addr protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryUnbondingDelegationRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryUnbondingDelegationRequest")
+	fd_QueryUnbondingDelegationRequest_delegator_addr = md_QueryUnbondingDelegationRequest.Fields().ByName("delegator_addr")
+	fd_QueryUnbondingDelegationRequest_validator_addr = md_QueryUnbondingDelegationRequest.Fields().ByName("validator_addr")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryUnbondingDelegationRequest)(nil)
+
+type fastReflection_QueryUnbondingDelegationRequest QueryUnbondingDelegationRequest
+
+func (x *QueryUnbondingDelegationRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryUnbondingDelegationRequest)(x)
+}
+
+func (x *QueryUnbondingDelegationRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryUnbondingDelegationRequest_messageType fastReflection_QueryUnbondingDelegationRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryUnbondingDelegationRequest_messageType{}
+
+type fastReflection_QueryUnbondingDelegationRequest_messageType struct{}
+
+func (x fastReflection_QueryUnbondingDelegationRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryUnbondingDelegationRequest)(nil)
+}
+func (x fastReflection_QueryUnbondingDelegationRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryUnbondingDelegationRequest)
+}
+func (x fastReflection_QueryUnbondingDelegationRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryUnbondingDelegationRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryUnbondingDelegationRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryUnbondingDelegationRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryUnbondingDelegationRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryUnbondingDelegationRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryUnbondingDelegationRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryUnbondingDelegationRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryUnbondingDelegationRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryUnbondingDelegationRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryUnbondingDelegationRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddr != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddr)
+		if !f(fd_QueryUnbondingDelegationRequest_delegator_addr, value) {
+			return
+		}
+	}
+	if x.ValidatorAddr != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddr)
+		if !f(fd_QueryUnbondingDelegationRequest_validator_addr, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryUnbondingDelegationRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.delegator_addr":
+		return x.DelegatorAddr != ""
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.validator_addr":
+		return x.ValidatorAddr != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryUnbondingDelegationRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.delegator_addr":
+		x.DelegatorAddr = ""
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.validator_addr":
+		x.ValidatorAddr = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryUnbondingDelegationRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.delegator_addr":
+		value := x.DelegatorAddr
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.validator_addr":
+		value := x.ValidatorAddr
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryUnbondingDelegationRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.delegator_addr":
+		x.DelegatorAddr = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.validator_addr":
+		x.ValidatorAddr = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryUnbondingDelegationRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.delegator_addr":
+		panic(fmt.Errorf("field delegator_addr of message cosmos.staking.v1beta1.QueryUnbondingDelegationRequest is not mutable"))
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.validator_addr":
+		panic(fmt.Errorf("field validator_addr of message cosmos.staking.v1beta1.QueryUnbondingDelegationRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryUnbondingDelegationRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.delegator_addr":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest.validator_addr":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryUnbondingDelegationRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryUnbondingDelegationRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryUnbondingDelegationRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryUnbondingDelegationRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryUnbondingDelegationRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryUnbondingDelegationRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryUnbondingDelegationRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryUnbondingDelegationRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.ValidatorAddr) > 0 {
+			i -= len(x.ValidatorAddr)
+			copy(dAtA[i:], x.ValidatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddr)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddr) > 0 {
+			i -= len(x.DelegatorAddr)
+			copy(dAtA[i:], x.DelegatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddr)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryUnbondingDelegationRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryUnbondingDelegationRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryUnbondingDelegationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryUnbondingDelegationResponse        protoreflect.MessageDescriptor
+	fd_QueryUnbondingDelegationResponse_unbond protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryUnbondingDelegationResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryUnbondingDelegationResponse")
+	fd_QueryUnbondingDelegationResponse_unbond = md_QueryUnbondingDelegationResponse.Fields().ByName("unbond")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryUnbondingDelegationResponse)(nil)
+
+type fastReflection_QueryUnbondingDelegationResponse QueryUnbondingDelegationResponse
+
+func (x *QueryUnbondingDelegationResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryUnbondingDelegationResponse)(x)
+}
+
+func (x *QueryUnbondingDelegationResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryUnbondingDelegationResponse_messageType fastReflection_QueryUnbondingDelegationResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryUnbondingDelegationResponse_messageType{}
+
+type fastReflection_QueryUnbondingDelegationResponse_messageType struct{}
+
+func (x fastReflection_QueryUnbondingDelegationResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryUnbondingDelegationResponse)(nil)
+}
+func (x fastReflection_QueryUnbondingDelegationResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryUnbondingDelegationResponse)
+}
+func (x fastReflection_QueryUnbondingDelegationResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryUnbondingDelegationResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryUnbondingDelegationResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryUnbondingDelegationResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryUnbondingDelegationResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryUnbondingDelegationResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryUnbondingDelegationResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryUnbondingDelegationResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryUnbondingDelegationResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryUnbondingDelegationResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryUnbondingDelegationResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Unbond != nil {
+		value := protoreflect.ValueOfMessage(x.Unbond.ProtoReflect())
+		if !f(fd_QueryUnbondingDelegationResponse_unbond, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryUnbondingDelegationResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse.unbond":
+		return x.Unbond != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryUnbondingDelegationResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse.unbond":
+		x.Unbond = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryUnbondingDelegationResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse.unbond":
+		value := x.Unbond
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryUnbondingDelegationResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse.unbond":
+		x.Unbond = value.Message().Interface().(*UnbondingDelegation)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryUnbondingDelegationResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse.unbond":
+		if x.Unbond == nil {
+			x.Unbond = new(UnbondingDelegation)
+		}
+		return protoreflect.ValueOfMessage(x.Unbond.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryUnbondingDelegationResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse.unbond":
+		m := new(UnbondingDelegation)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryUnbondingDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryUnbondingDelegationResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryUnbondingDelegationResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryUnbondingDelegationResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryUnbondingDelegationResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryUnbondingDelegationResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryUnbondingDelegationResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryUnbondingDelegationResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Unbond != nil {
+			l = options.Size(x.Unbond)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryUnbondingDelegationResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Unbond != nil {
+			encoded, err := options.Marshal(x.Unbond)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryUnbondingDelegationResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryUnbondingDelegationResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryUnbondingDelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Unbond", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Unbond == nil {
+					x.Unbond = &UnbondingDelegation{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Unbond); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryDelegatorDelegationsRequest                protoreflect.MessageDescriptor
+	fd_QueryDelegatorDelegationsRequest_delegator_addr protoreflect.FieldDescriptor
+	fd_QueryDelegatorDelegationsRequest_pagination     protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryDelegatorDelegationsRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryDelegatorDelegationsRequest")
+	fd_QueryDelegatorDelegationsRequest_delegator_addr = md_QueryDelegatorDelegationsRequest.Fields().ByName("delegator_addr")
+	fd_QueryDelegatorDelegationsRequest_pagination = md_QueryDelegatorDelegationsRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDelegatorDelegationsRequest)(nil)
+
+type fastReflection_QueryDelegatorDelegationsRequest QueryDelegatorDelegationsRequest
+
+func (x *QueryDelegatorDelegationsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorDelegationsRequest)(x)
+}
+
+func (x *QueryDelegatorDelegationsRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryDelegatorDelegationsRequest_messageType fastReflection_QueryDelegatorDelegationsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDelegatorDelegationsRequest_messageType{}
+
+type fastReflection_QueryDelegatorDelegationsRequest_messageType struct{}
+
+func (x fastReflection_QueryDelegatorDelegationsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorDelegationsRequest)(nil)
+}
+func (x fastReflection_QueryDelegatorDelegationsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorDelegationsRequest)
+}
+func (x fastReflection_QueryDelegatorDelegationsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorDelegationsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorDelegationsRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDelegatorDelegationsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorDelegationsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryDelegatorDelegationsRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddr != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddr)
+		if !f(fd_QueryDelegatorDelegationsRequest_delegator_addr, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryDelegatorDelegationsRequest_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.delegator_addr":
+		return x.DelegatorAddr != ""
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.delegator_addr":
+		x.DelegatorAddr = ""
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.delegator_addr":
+		value := x.DelegatorAddr
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.delegator_addr":
+		x.DelegatorAddr = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.delegator_addr":
+		panic(fmt.Errorf("field delegator_addr of message cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.delegator_addr":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryDelegatorDelegationsRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryDelegatorDelegationsRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorDelegationsRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddr) > 0 {
+			i -= len(x.DelegatorAddr)
+			copy(dAtA[i:], x.DelegatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddr)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorDelegationsRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorDelegationsRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorDelegationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_QueryDelegatorDelegationsResponse_1_list)(nil)
+
+type _QueryDelegatorDelegationsResponse_1_list struct {
+	list *[]*DelegationResponse
+}
+
+func (x *_QueryDelegatorDelegationsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryDelegatorDelegationsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryDelegatorDelegationsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DelegationResponse)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryDelegatorDelegationsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DelegationResponse)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryDelegatorDelegationsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(DelegationResponse)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDelegatorDelegationsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryDelegatorDelegationsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(DelegationResponse)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDelegatorDelegationsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryDelegatorDelegationsResponse                      protoreflect.MessageDescriptor
+	fd_QueryDelegatorDelegationsResponse_delegation_responses protoreflect.FieldDescriptor
+	fd_QueryDelegatorDelegationsResponse_pagination           protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryDelegatorDelegationsResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryDelegatorDelegationsResponse")
+	fd_QueryDelegatorDelegationsResponse_delegation_responses = md_QueryDelegatorDelegationsResponse.Fields().ByName("delegation_responses")
+	fd_QueryDelegatorDelegationsResponse_pagination = md_QueryDelegatorDelegationsResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDelegatorDelegationsResponse)(nil)
+
+type fastReflection_QueryDelegatorDelegationsResponse QueryDelegatorDelegationsResponse
+
+func (x *QueryDelegatorDelegationsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorDelegationsResponse)(x)
+}
+
+func (x *QueryDelegatorDelegationsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryDelegatorDelegationsResponse_messageType fastReflection_QueryDelegatorDelegationsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDelegatorDelegationsResponse_messageType{}
+
+type fastReflection_QueryDelegatorDelegationsResponse_messageType struct{}
+
+func (x fastReflection_QueryDelegatorDelegationsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorDelegationsResponse)(nil)
+}
+func (x fastReflection_QueryDelegatorDelegationsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorDelegationsResponse)
+}
+func (x fastReflection_QueryDelegatorDelegationsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorDelegationsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorDelegationsResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDelegatorDelegationsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorDelegationsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryDelegatorDelegationsResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.DelegationResponses) != 0 {
+		value := protoreflect.ValueOfList(&_QueryDelegatorDelegationsResponse_1_list{list: &x.DelegationResponses})
+		if !f(fd_QueryDelegatorDelegationsResponse_delegation_responses, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryDelegatorDelegationsResponse_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.delegation_responses":
+		return len(x.DelegationResponses) != 0
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.delegation_responses":
+		x.DelegationResponses = nil
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.delegation_responses":
+		if len(x.DelegationResponses) == 0 {
+			return protoreflect.ValueOfList(&_QueryDelegatorDelegationsResponse_1_list{})
+		}
+		listValue := &_QueryDelegatorDelegationsResponse_1_list{list: &x.DelegationResponses}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.delegation_responses":
+		lv := value.List()
+		clv := lv.(*_QueryDelegatorDelegationsResponse_1_list)
+		x.DelegationResponses = *clv.list
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.delegation_responses":
+		if x.DelegationResponses == nil {
+			x.DelegationResponses = []*DelegationResponse{}
+		}
+		value := &_QueryDelegatorDelegationsResponse_1_list{list: &x.DelegationResponses}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.delegation_responses":
+		list := []*DelegationResponse{}
+		return protoreflect.ValueOfList(&_QueryDelegatorDelegationsResponse_1_list{list: &list})
+	case "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.pagination":
+		m := new(v1beta1.PageResponse)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryDelegatorDelegationsResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryDelegatorDelegationsResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.DelegationResponses) > 0 {
+			for _, e := range x.DelegationResponses {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorDelegationsResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegationResponses) > 0 {
+			for iNdEx := len(x.DelegationResponses) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.DelegationResponses[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorDelegationsResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorDelegationsResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorDelegationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegationResponses", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegationResponses = append(x.DelegationResponses, &DelegationResponse{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DelegationResponses[len(x.DelegationResponses)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryDelegatorUnbondingDelegationsRequest                protoreflect.MessageDescriptor
+	fd_QueryDelegatorUnbondingDelegationsRequest_delegator_addr protoreflect.FieldDescriptor
+	fd_QueryDelegatorUnbondingDelegationsRequest_pagination     protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryDelegatorUnbondingDelegationsRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryDelegatorUnbondingDelegationsRequest")
+	fd_QueryDelegatorUnbondingDelegationsRequest_delegator_addr = md_QueryDelegatorUnbondingDelegationsRequest.Fields().ByName("delegator_addr")
+	fd_QueryDelegatorUnbondingDelegationsRequest_pagination = md_QueryDelegatorUnbondingDelegationsRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDelegatorUnbondingDelegationsRequest)(nil)
+
+type fastReflection_QueryDelegatorUnbondingDelegationsRequest QueryDelegatorUnbondingDelegationsRequest
+
+func (x *QueryDelegatorUnbondingDelegationsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorUnbondingDelegationsRequest)(x)
+}
+
+func (x *QueryDelegatorUnbondingDelegationsRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryDelegatorUnbondingDelegationsRequest_messageType fastReflection_QueryDelegatorUnbondingDelegationsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDelegatorUnbondingDelegationsRequest_messageType{}
+
+type fastReflection_QueryDelegatorUnbondingDelegationsRequest_messageType struct{}
+
+func (x fastReflection_QueryDelegatorUnbondingDelegationsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorUnbondingDelegationsRequest)(nil)
+}
+func (x fastReflection_QueryDelegatorUnbondingDelegationsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorUnbondingDelegationsRequest)
+}
+func (x fastReflection_QueryDelegatorUnbondingDelegationsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorUnbondingDelegationsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorUnbondingDelegationsRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDelegatorUnbondingDelegationsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorUnbondingDelegationsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryDelegatorUnbondingDelegationsRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddr != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddr)
+		if !f(fd_QueryDelegatorUnbondingDelegationsRequest_delegator_addr, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryDelegatorUnbondingDelegationsRequest_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.delegator_addr":
+		return x.DelegatorAddr != ""
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.delegator_addr":
+		x.DelegatorAddr = ""
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.delegator_addr":
+		value := x.DelegatorAddr
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.delegator_addr":
+		x.DelegatorAddr = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.delegator_addr":
+		panic(fmt.Errorf("field delegator_addr of message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.delegator_addr":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryDelegatorUnbondingDelegationsRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorUnbondingDelegationsRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddr) > 0 {
+			i -= len(x.DelegatorAddr)
+			copy(dAtA[i:], x.DelegatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddr)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorUnbondingDelegationsRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorUnbondingDelegationsRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorUnbondingDelegationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_QueryDelegatorUnbondingDelegationsResponse_1_list)(nil)
+
+type _QueryDelegatorUnbondingDelegationsResponse_1_list struct {
+	list *[]*UnbondingDelegation
+}
+
+func (x *_QueryDelegatorUnbondingDelegationsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryDelegatorUnbondingDelegationsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryDelegatorUnbondingDelegationsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*UnbondingDelegation)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryDelegatorUnbondingDelegationsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*UnbondingDelegation)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryDelegatorUnbondingDelegationsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(UnbondingDelegation)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDelegatorUnbondingDelegationsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryDelegatorUnbondingDelegationsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(UnbondingDelegation)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDelegatorUnbondingDelegationsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryDelegatorUnbondingDelegationsResponse                     protoreflect.MessageDescriptor
+	fd_QueryDelegatorUnbondingDelegationsResponse_unbonding_responses protoreflect.FieldDescriptor
+	fd_QueryDelegatorUnbondingDelegationsResponse_pagination          protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryDelegatorUnbondingDelegationsResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryDelegatorUnbondingDelegationsResponse")
+	fd_QueryDelegatorUnbondingDelegationsResponse_unbonding_responses = md_QueryDelegatorUnbondingDelegationsResponse.Fields().ByName("unbonding_responses")
+	fd_QueryDelegatorUnbondingDelegationsResponse_pagination = md_QueryDelegatorUnbondingDelegationsResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDelegatorUnbondingDelegationsResponse)(nil)
+
+type fastReflection_QueryDelegatorUnbondingDelegationsResponse QueryDelegatorUnbondingDelegationsResponse
+
+func (x *QueryDelegatorUnbondingDelegationsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorUnbondingDelegationsResponse)(x)
+}
+
+func (x *QueryDelegatorUnbondingDelegationsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryDelegatorUnbondingDelegationsResponse_messageType fastReflection_QueryDelegatorUnbondingDelegationsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDelegatorUnbondingDelegationsResponse_messageType{}
+
+type fastReflection_QueryDelegatorUnbondingDelegationsResponse_messageType struct{}
+
+func (x fastReflection_QueryDelegatorUnbondingDelegationsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorUnbondingDelegationsResponse)(nil)
+}
+func (x fastReflection_QueryDelegatorUnbondingDelegationsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorUnbondingDelegationsResponse)
+}
+func (x fastReflection_QueryDelegatorUnbondingDelegationsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorUnbondingDelegationsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorUnbondingDelegationsResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDelegatorUnbondingDelegationsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorUnbondingDelegationsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryDelegatorUnbondingDelegationsResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.UnbondingResponses) != 0 {
+		value := protoreflect.ValueOfList(&_QueryDelegatorUnbondingDelegationsResponse_1_list{list: &x.UnbondingResponses})
+		if !f(fd_QueryDelegatorUnbondingDelegationsResponse_unbonding_responses, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryDelegatorUnbondingDelegationsResponse_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.unbonding_responses":
+		return len(x.UnbondingResponses) != 0
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.unbonding_responses":
+		x.UnbondingResponses = nil
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.unbonding_responses":
+		if len(x.UnbondingResponses) == 0 {
+			return protoreflect.ValueOfList(&_QueryDelegatorUnbondingDelegationsResponse_1_list{})
+		}
+		listValue := &_QueryDelegatorUnbondingDelegationsResponse_1_list{list: &x.UnbondingResponses}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.unbonding_responses":
+		lv := value.List()
+		clv := lv.(*_QueryDelegatorUnbondingDelegationsResponse_1_list)
+		x.UnbondingResponses = *clv.list
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.unbonding_responses":
+		if x.UnbondingResponses == nil {
+			x.UnbondingResponses = []*UnbondingDelegation{}
+		}
+		value := &_QueryDelegatorUnbondingDelegationsResponse_1_list{list: &x.UnbondingResponses}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.unbonding_responses":
+		list := []*UnbondingDelegation{}
+		return protoreflect.ValueOfList(&_QueryDelegatorUnbondingDelegationsResponse_1_list{list: &list})
+	case "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.pagination":
+		m := new(v1beta1.PageResponse)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryDelegatorUnbondingDelegationsResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryDelegatorUnbondingDelegationsResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.UnbondingResponses) > 0 {
+			for _, e := range x.UnbondingResponses {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorUnbondingDelegationsResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.UnbondingResponses) > 0 {
+			for iNdEx := len(x.UnbondingResponses) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.UnbondingResponses[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorUnbondingDelegationsResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorUnbondingDelegationsResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorUnbondingDelegationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingResponses", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.UnbondingResponses = append(x.UnbondingResponses, &UnbondingDelegation{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.UnbondingResponses[len(x.UnbondingResponses)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryRedelegationsRequest                    protoreflect.MessageDescriptor
+	fd_QueryRedelegationsRequest_delegator_addr     protoreflect.FieldDescriptor
+	fd_QueryRedelegationsRequest_src_validator_addr protoreflect.FieldDescriptor
+	fd_QueryRedelegationsRequest_dst_validator_addr protoreflect.FieldDescriptor
+	fd_QueryRedelegationsRequest_pagination         protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryRedelegationsRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryRedelegationsRequest")
+	fd_QueryRedelegationsRequest_delegator_addr = md_QueryRedelegationsRequest.Fields().ByName("delegator_addr")
+	fd_QueryRedelegationsRequest_src_validator_addr = md_QueryRedelegationsRequest.Fields().ByName("src_validator_addr")
+	fd_QueryRedelegationsRequest_dst_validator_addr = md_QueryRedelegationsRequest.Fields().ByName("dst_validator_addr")
+	fd_QueryRedelegationsRequest_pagination = md_QueryRedelegationsRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryRedelegationsRequest)(nil)
+
+type fastReflection_QueryRedelegationsRequest QueryRedelegationsRequest
+
+func (x *QueryRedelegationsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryRedelegationsRequest)(x)
+}
+
+func (x *QueryRedelegationsRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryRedelegationsRequest_messageType fastReflection_QueryRedelegationsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryRedelegationsRequest_messageType{}
+
+type fastReflection_QueryRedelegationsRequest_messageType struct{}
+
+func (x fastReflection_QueryRedelegationsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryRedelegationsRequest)(nil)
+}
+func (x fastReflection_QueryRedelegationsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryRedelegationsRequest)
+}
+func (x fastReflection_QueryRedelegationsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryRedelegationsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryRedelegationsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryRedelegationsRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryRedelegationsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryRedelegationsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryRedelegationsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryRedelegationsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryRedelegationsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryRedelegationsRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryRedelegationsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddr != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddr)
+		if !f(fd_QueryRedelegationsRequest_delegator_addr, value) {
+			return
+		}
+	}
+	if x.SrcValidatorAddr != "" {
+		value := protoreflect.ValueOfString(x.SrcValidatorAddr)
+		if !f(fd_QueryRedelegationsRequest_src_validator_addr, value) {
+			return
+		}
+	}
+	if x.DstValidatorAddr != "" {
+		value := protoreflect.ValueOfString(x.DstValidatorAddr)
+		if !f(fd_QueryRedelegationsRequest_dst_validator_addr, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryRedelegationsRequest_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryRedelegationsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.delegator_addr":
+		return x.DelegatorAddr != ""
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.src_validator_addr":
+		return x.SrcValidatorAddr != ""
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.dst_validator_addr":
+		return x.DstValidatorAddr != ""
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryRedelegationsRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.delegator_addr":
+		x.DelegatorAddr = ""
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.src_validator_addr":
+		x.SrcValidatorAddr = ""
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.dst_validator_addr":
+		x.DstValidatorAddr = ""
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryRedelegationsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.delegator_addr":
+		value := x.DelegatorAddr
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.src_validator_addr":
+		value := x.SrcValidatorAddr
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.dst_validator_addr":
+		value := x.DstValidatorAddr
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryRedelegationsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.delegator_addr":
+		x.DelegatorAddr = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.src_validator_addr":
+		x.SrcValidatorAddr = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.dst_validator_addr":
+		x.DstValidatorAddr = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryRedelegationsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.delegator_addr":
+		panic(fmt.Errorf("field delegator_addr of message cosmos.staking.v1beta1.QueryRedelegationsRequest is not mutable"))
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.src_validator_addr":
+		panic(fmt.Errorf("field src_validator_addr of message cosmos.staking.v1beta1.QueryRedelegationsRequest is not mutable"))
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.dst_validator_addr":
+		panic(fmt.Errorf("field dst_validator_addr of message cosmos.staking.v1beta1.QueryRedelegationsRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryRedelegationsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.delegator_addr":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.src_validator_addr":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.dst_validator_addr":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryRedelegationsRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryRedelegationsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryRedelegationsRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryRedelegationsRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryRedelegationsRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryRedelegationsRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryRedelegationsRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryRedelegationsRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.SrcValidatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.DstValidatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryRedelegationsRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.DstValidatorAddr) > 0 {
+			i -= len(x.DstValidatorAddr)
+			copy(dAtA[i:], x.DstValidatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DstValidatorAddr)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.SrcValidatorAddr) > 0 {
+			i -= len(x.SrcValidatorAddr)
+			copy(dAtA[i:], x.SrcValidatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SrcValidatorAddr)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddr) > 0 {
+			i -= len(x.DelegatorAddr)
+			copy(dAtA[i:], x.DelegatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddr)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryRedelegationsRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRedelegationsRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRedelegationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SrcValidatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.SrcValidatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DstValidatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DstValidatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_QueryRedelegationsResponse_1_list)(nil)
+
+type _QueryRedelegationsResponse_1_list struct {
+	list *[]*RedelegationResponse
+}
+
+func (x *_QueryRedelegationsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryRedelegationsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryRedelegationsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*RedelegationResponse)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryRedelegationsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*RedelegationResponse)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryRedelegationsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(RedelegationResponse)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryRedelegationsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryRedelegationsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(RedelegationResponse)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryRedelegationsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryRedelegationsResponse                        protoreflect.MessageDescriptor
+	fd_QueryRedelegationsResponse_redelegation_responses protoreflect.FieldDescriptor
+	fd_QueryRedelegationsResponse_pagination             protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryRedelegationsResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryRedelegationsResponse")
+	fd_QueryRedelegationsResponse_redelegation_responses = md_QueryRedelegationsResponse.Fields().ByName("redelegation_responses")
+	fd_QueryRedelegationsResponse_pagination = md_QueryRedelegationsResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryRedelegationsResponse)(nil)
+
+type fastReflection_QueryRedelegationsResponse QueryRedelegationsResponse
+
+func (x *QueryRedelegationsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryRedelegationsResponse)(x)
+}
+
+func (x *QueryRedelegationsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryRedelegationsResponse_messageType fastReflection_QueryRedelegationsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryRedelegationsResponse_messageType{}
+
+type fastReflection_QueryRedelegationsResponse_messageType struct{}
+
+func (x fastReflection_QueryRedelegationsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryRedelegationsResponse)(nil)
+}
+func (x fastReflection_QueryRedelegationsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryRedelegationsResponse)
+}
+func (x fastReflection_QueryRedelegationsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryRedelegationsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryRedelegationsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryRedelegationsResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryRedelegationsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryRedelegationsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryRedelegationsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryRedelegationsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryRedelegationsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryRedelegationsResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryRedelegationsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.RedelegationResponses) != 0 {
+		value := protoreflect.ValueOfList(&_QueryRedelegationsResponse_1_list{list: &x.RedelegationResponses})
+		if !f(fd_QueryRedelegationsResponse_redelegation_responses, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryRedelegationsResponse_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryRedelegationsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.redelegation_responses":
+		return len(x.RedelegationResponses) != 0
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryRedelegationsResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.redelegation_responses":
+		x.RedelegationResponses = nil
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryRedelegationsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.redelegation_responses":
+		if len(x.RedelegationResponses) == 0 {
+			return protoreflect.ValueOfList(&_QueryRedelegationsResponse_1_list{})
+		}
+		listValue := &_QueryRedelegationsResponse_1_list{list: &x.RedelegationResponses}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryRedelegationsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.redelegation_responses":
+		lv := value.List()
+		clv := lv.(*_QueryRedelegationsResponse_1_list)
+		x.RedelegationResponses = *clv.list
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryRedelegationsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.redelegation_responses":
+		if x.RedelegationResponses == nil {
+			x.RedelegationResponses = []*RedelegationResponse{}
+		}
+		value := &_QueryRedelegationsResponse_1_list{list: &x.RedelegationResponses}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryRedelegationsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.redelegation_responses":
+		list := []*RedelegationResponse{}
+		return protoreflect.ValueOfList(&_QueryRedelegationsResponse_1_list{list: &list})
+	case "cosmos.staking.v1beta1.QueryRedelegationsResponse.pagination":
+		m := new(v1beta1.PageResponse)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryRedelegationsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryRedelegationsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryRedelegationsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryRedelegationsResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryRedelegationsResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryRedelegationsResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryRedelegationsResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryRedelegationsResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryRedelegationsResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.RedelegationResponses) > 0 {
+			for _, e := range x.RedelegationResponses {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryRedelegationsResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.RedelegationResponses) > 0 {
+			for iNdEx := len(x.RedelegationResponses) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.RedelegationResponses[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryRedelegationsResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRedelegationsResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRedelegationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RedelegationResponses", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.RedelegationResponses = append(x.RedelegationResponses, &RedelegationResponse{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.RedelegationResponses[len(x.RedelegationResponses)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryDelegatorValidatorsRequest                protoreflect.MessageDescriptor
+	fd_QueryDelegatorValidatorsRequest_delegator_addr protoreflect.FieldDescriptor
+	fd_QueryDelegatorValidatorsRequest_pagination     protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryDelegatorValidatorsRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryDelegatorValidatorsRequest")
+	fd_QueryDelegatorValidatorsRequest_delegator_addr = md_QueryDelegatorValidatorsRequest.Fields().ByName("delegator_addr")
+	fd_QueryDelegatorValidatorsRequest_pagination = md_QueryDelegatorValidatorsRequest.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDelegatorValidatorsRequest)(nil)
+
+type fastReflection_QueryDelegatorValidatorsRequest QueryDelegatorValidatorsRequest
+
+func (x *QueryDelegatorValidatorsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorValidatorsRequest)(x)
+}
+
+func (x *QueryDelegatorValidatorsRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryDelegatorValidatorsRequest_messageType fastReflection_QueryDelegatorValidatorsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDelegatorValidatorsRequest_messageType{}
+
+type fastReflection_QueryDelegatorValidatorsRequest_messageType struct{}
+
+func (x fastReflection_QueryDelegatorValidatorsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorValidatorsRequest)(nil)
+}
+func (x fastReflection_QueryDelegatorValidatorsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorValidatorsRequest)
+}
+func (x fastReflection_QueryDelegatorValidatorsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorValidatorsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorValidatorsRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDelegatorValidatorsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorValidatorsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryDelegatorValidatorsRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddr != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddr)
+		if !f(fd_QueryDelegatorValidatorsRequest_delegator_addr, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryDelegatorValidatorsRequest_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.delegator_addr":
+		return x.DelegatorAddr != ""
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.delegator_addr":
+		x.DelegatorAddr = ""
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.delegator_addr":
+		value := x.DelegatorAddr
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.delegator_addr":
+		x.DelegatorAddr = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.delegator_addr":
+		panic(fmt.Errorf("field delegator_addr of message cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.delegator_addr":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryDelegatorValidatorsRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryDelegatorValidatorsRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorValidatorsRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddr) > 0 {
+			i -= len(x.DelegatorAddr)
+			copy(dAtA[i:], x.DelegatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddr)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorValidatorsRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorValidatorsRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorValidatorsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_QueryDelegatorValidatorsResponse_1_list)(nil)
+
+type _QueryDelegatorValidatorsResponse_1_list struct {
+	list *[]*Validator
+}
+
+func (x *_QueryDelegatorValidatorsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryDelegatorValidatorsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryDelegatorValidatorsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Validator)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryDelegatorValidatorsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Validator)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryDelegatorValidatorsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(Validator)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDelegatorValidatorsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryDelegatorValidatorsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(Validator)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDelegatorValidatorsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryDelegatorValidatorsResponse            protoreflect.MessageDescriptor
+	fd_QueryDelegatorValidatorsResponse_validators protoreflect.FieldDescriptor
+	fd_QueryDelegatorValidatorsResponse_pagination protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryDelegatorValidatorsResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryDelegatorValidatorsResponse")
+	fd_QueryDelegatorValidatorsResponse_validators = md_QueryDelegatorValidatorsResponse.Fields().ByName("validators")
+	fd_QueryDelegatorValidatorsResponse_pagination = md_QueryDelegatorValidatorsResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDelegatorValidatorsResponse)(nil)
+
+type fastReflection_QueryDelegatorValidatorsResponse QueryDelegatorValidatorsResponse
+
+func (x *QueryDelegatorValidatorsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorValidatorsResponse)(x)
+}
+
+func (x *QueryDelegatorValidatorsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryDelegatorValidatorsResponse_messageType fastReflection_QueryDelegatorValidatorsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDelegatorValidatorsResponse_messageType{}
+
+type fastReflection_QueryDelegatorValidatorsResponse_messageType struct{}
+
+func (x fastReflection_QueryDelegatorValidatorsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorValidatorsResponse)(nil)
+}
+func (x fastReflection_QueryDelegatorValidatorsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorValidatorsResponse)
+}
+func (x fastReflection_QueryDelegatorValidatorsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorValidatorsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorValidatorsResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDelegatorValidatorsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorValidatorsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryDelegatorValidatorsResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Validators) != 0 {
+		value := protoreflect.ValueOfList(&_QueryDelegatorValidatorsResponse_1_list{list: &x.Validators})
+		if !f(fd_QueryDelegatorValidatorsResponse_validators, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryDelegatorValidatorsResponse_pagination, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.validators":
+		return len(x.Validators) != 0
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.pagination":
+		return x.Pagination != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.validators":
+		x.Validators = nil
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.pagination":
+		x.Pagination = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.validators":
+		if len(x.Validators) == 0 {
+			return protoreflect.ValueOfList(&_QueryDelegatorValidatorsResponse_1_list{})
+		}
+		listValue := &_QueryDelegatorValidatorsResponse_1_list{list: &x.Validators}
+		return protoreflect.ValueOfList(listValue)
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.validators":
+		lv := value.List()
+		clv := lv.(*_QueryDelegatorValidatorsResponse_1_list)
+		x.Validators = *clv.list
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.validators":
+		if x.Validators == nil {
+			x.Validators = []*Validator{}
+		}
+		value := &_QueryDelegatorValidatorsResponse_1_list{list: &x.Validators}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.validators":
+		list := []*Validator{}
+		return protoreflect.ValueOfList(&_QueryDelegatorValidatorsResponse_1_list{list: &list})
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.pagination":
+		m := new(v1beta1.PageResponse)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryDelegatorValidatorsResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryDelegatorValidatorsResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.Validators) > 0 {
+			for _, e := range x.Validators {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorValidatorsResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.Validators) > 0 {
+			for iNdEx := len(x.Validators) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Validators[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorValidatorsResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorValidatorsResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorValidatorsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Validators = append(x.Validators, &Validator{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Validators[len(x.Validators)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryDelegatorValidatorRequest                protoreflect.MessageDescriptor
+	fd_QueryDelegatorValidatorRequest_delegator_addr protoreflect.FieldDescriptor
+	fd_QueryDelegatorValidatorRequest_validator_addr protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryDelegatorValidatorRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryDelegatorValidatorRequest")
+	fd_QueryDelegatorValidatorRequest_delegator_addr = md_QueryDelegatorValidatorRequest.Fields().ByName("delegator_addr")
+	fd_QueryDelegatorValidatorRequest_validator_addr = md_QueryDelegatorValidatorRequest.Fields().ByName("validator_addr")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDelegatorValidatorRequest)(nil)
+
+type fastReflection_QueryDelegatorValidatorRequest QueryDelegatorValidatorRequest
+
+func (x *QueryDelegatorValidatorRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorValidatorRequest)(x)
+}
+
+func (x *QueryDelegatorValidatorRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryDelegatorValidatorRequest_messageType fastReflection_QueryDelegatorValidatorRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDelegatorValidatorRequest_messageType{}
+
+type fastReflection_QueryDelegatorValidatorRequest_messageType struct{}
+
+func (x fastReflection_QueryDelegatorValidatorRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorValidatorRequest)(nil)
+}
+func (x fastReflection_QueryDelegatorValidatorRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorValidatorRequest)
+}
+func (x fastReflection_QueryDelegatorValidatorRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorValidatorRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryDelegatorValidatorRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorValidatorRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryDelegatorValidatorRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDelegatorValidatorRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryDelegatorValidatorRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorValidatorRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryDelegatorValidatorRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryDelegatorValidatorRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryDelegatorValidatorRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddr != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddr)
+		if !f(fd_QueryDelegatorValidatorRequest_delegator_addr, value) {
+			return
+		}
+	}
+	if x.ValidatorAddr != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddr)
+		if !f(fd_QueryDelegatorValidatorRequest_validator_addr, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryDelegatorValidatorRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.delegator_addr":
+		return x.DelegatorAddr != ""
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.validator_addr":
+		return x.ValidatorAddr != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.delegator_addr":
+		x.DelegatorAddr = ""
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.validator_addr":
+		x.ValidatorAddr = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryDelegatorValidatorRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.delegator_addr":
+		value := x.DelegatorAddr
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.validator_addr":
+		value := x.ValidatorAddr
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.delegator_addr":
+		x.DelegatorAddr = value.Interface().(string)
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.validator_addr":
+		x.ValidatorAddr = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.delegator_addr":
+		panic(fmt.Errorf("field delegator_addr of message cosmos.staking.v1beta1.QueryDelegatorValidatorRequest is not mutable"))
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.validator_addr":
+		panic(fmt.Errorf("field validator_addr of message cosmos.staking.v1beta1.QueryDelegatorValidatorRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryDelegatorValidatorRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.delegator_addr":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest.validator_addr":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryDelegatorValidatorRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryDelegatorValidatorRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryDelegatorValidatorRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryDelegatorValidatorRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryDelegatorValidatorRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryDelegatorValidatorRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorAddr)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorValidatorRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.ValidatorAddr) > 0 {
+			i -= len(x.ValidatorAddr)
+			copy(dAtA[i:], x.ValidatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddr)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddr) > 0 {
+			i -= len(x.DelegatorAddr)
+			copy(dAtA[i:], x.DelegatorAddr)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddr)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorValidatorRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorValidatorRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorValidatorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddr = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryDelegatorValidatorResponse           protoreflect.MessageDescriptor
+	fd_QueryDelegatorValidatorResponse_validator protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryDelegatorValidatorResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryDelegatorValidatorResponse")
+	fd_QueryDelegatorValidatorResponse_validator = md_QueryDelegatorValidatorResponse.Fields().ByName("validator")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDelegatorValidatorResponse)(nil)
+
+type fastReflection_QueryDelegatorValidatorResponse QueryDelegatorValidatorResponse
+
+func (x *QueryDelegatorValidatorResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorValidatorResponse)(x)
+}
+
+func (x *QueryDelegatorValidatorResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryDelegatorValidatorResponse_messageType fastReflection_QueryDelegatorValidatorResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDelegatorValidatorResponse_messageType{}
+
+type fastReflection_QueryDelegatorValidatorResponse_messageType struct{}
+
+func (x fastReflection_QueryDelegatorValidatorResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDelegatorValidatorResponse)(nil)
+}
+func (x fastReflection_QueryDelegatorValidatorResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorValidatorResponse)
+}
+func (x fastReflection_QueryDelegatorValidatorResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorValidatorResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryDelegatorValidatorResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDelegatorValidatorResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryDelegatorValidatorResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDelegatorValidatorResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryDelegatorValidatorResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryDelegatorValidatorResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryDelegatorValidatorResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryDelegatorValidatorResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryDelegatorValidatorResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Validator != nil {
+		value := protoreflect.ValueOfMessage(x.Validator.ProtoReflect())
+		if !f(fd_QueryDelegatorValidatorResponse_validator, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryDelegatorValidatorResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse.validator":
+		return x.Validator != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse.validator":
+		x.Validator = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryDelegatorValidatorResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse.validator":
+		value := x.Validator
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse.validator":
+		x.Validator = value.Message().Interface().(*Validator)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse.validator":
+		if x.Validator == nil {
+			x.Validator = new(Validator)
+		}
+		return protoreflect.ValueOfMessage(x.Validator.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryDelegatorValidatorResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse.validator":
+		m := new(Validator)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryDelegatorValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryDelegatorValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryDelegatorValidatorResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryDelegatorValidatorResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryDelegatorValidatorResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryDelegatorValidatorResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryDelegatorValidatorResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryDelegatorValidatorResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryDelegatorValidatorResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Validator != nil {
+			l = options.Size(x.Validator)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorValidatorResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Validator != nil {
+			encoded, err := options.Marshal(x.Validator)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryDelegatorValidatorResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorValidatorResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDelegatorValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Validator == nil {
+					x.Validator = &Validator{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Validator); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryHistoricalInfoRequest        protoreflect.MessageDescriptor
+	fd_QueryHistoricalInfoRequest_height protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryHistoricalInfoRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryHistoricalInfoRequest")
+	fd_QueryHistoricalInfoRequest_height = md_QueryHistoricalInfoRequest.Fields().ByName("height")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryHistoricalInfoRequest)(nil)
+
+type fastReflection_QueryHistoricalInfoRequest QueryHistoricalInfoRequest
+
+func (x *QueryHistoricalInfoRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryHistoricalInfoRequest)(x)
+}
+
+func (x *QueryHistoricalInfoRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryHistoricalInfoRequest_messageType fastReflection_QueryHistoricalInfoRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryHistoricalInfoRequest_messageType{}
+
+type fastReflection_QueryHistoricalInfoRequest_messageType struct{}
+
+func (x fastReflection_QueryHistoricalInfoRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryHistoricalInfoRequest)(nil)
+}
+func (x fastReflection_QueryHistoricalInfoRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryHistoricalInfoRequest)
+}
+func (x fastReflection_QueryHistoricalInfoRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHistoricalInfoRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryHistoricalInfoRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHistoricalInfoRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryHistoricalInfoRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryHistoricalInfoRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryHistoricalInfoRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryHistoricalInfoRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryHistoricalInfoRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryHistoricalInfoRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryHistoricalInfoRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Height != int64(0) {
+		value := protoreflect.ValueOfInt64(x.Height)
+		if !f(fd_QueryHistoricalInfoRequest_height, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryHistoricalInfoRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoRequest.height":
+		return x.Height != int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryHistoricalInfoRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoRequest.height":
+		x.Height = int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryHistoricalInfoRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoRequest.height":
+		value := x.Height
+		return protoreflect.ValueOfInt64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryHistoricalInfoRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoRequest.height":
+		x.Height = value.Int()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryHistoricalInfoRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoRequest.height":
+		panic(fmt.Errorf("field height of message cosmos.staking.v1beta1.QueryHistoricalInfoRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryHistoricalInfoRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoRequest.height":
+		return protoreflect.ValueOfInt64(int64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryHistoricalInfoRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryHistoricalInfoRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryHistoricalInfoRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryHistoricalInfoRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryHistoricalInfoRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryHistoricalInfoRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryHistoricalInfoRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Height != 0 {
+			n += 1 + runtime.Sov(uint64(x.Height))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryHistoricalInfoRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Height != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Height))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryHistoricalInfoRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHistoricalInfoRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHistoricalInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
+				}
+				x.Height = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Height |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryHistoricalInfoResponse      protoreflect.MessageDescriptor
+	fd_QueryHistoricalInfoResponse_hist protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryHistoricalInfoResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryHistoricalInfoResponse")
+	fd_QueryHistoricalInfoResponse_hist = md_QueryHistoricalInfoResponse.Fields().ByName("hist")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryHistoricalInfoResponse)(nil)
+
+type fastReflection_QueryHistoricalInfoResponse QueryHistoricalInfoResponse
+
+func (x *QueryHistoricalInfoResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryHistoricalInfoResponse)(x)
+}
+
+func (x *QueryHistoricalInfoResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryHistoricalInfoResponse_messageType fastReflection_QueryHistoricalInfoResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryHistoricalInfoResponse_messageType{}
+
+type fastReflection_QueryHistoricalInfoResponse_messageType struct{}
+
+func (x fastReflection_QueryHistoricalInfoResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryHistoricalInfoResponse)(nil)
+}
+func (x fastReflection_QueryHistoricalInfoResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryHistoricalInfoResponse)
+}
+func (x fastReflection_QueryHistoricalInfoResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHistoricalInfoResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryHistoricalInfoResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHistoricalInfoResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryHistoricalInfoResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryHistoricalInfoResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryHistoricalInfoResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryHistoricalInfoResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryHistoricalInfoResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryHistoricalInfoResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryHistoricalInfoResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Hist != nil {
+		value := protoreflect.ValueOfMessage(x.Hist.ProtoReflect())
+		if !f(fd_QueryHistoricalInfoResponse_hist, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryHistoricalInfoResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoResponse.hist":
+		return x.Hist != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryHistoricalInfoResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoResponse.hist":
+		x.Hist = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryHistoricalInfoResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoResponse.hist":
+		value := x.Hist
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryHistoricalInfoResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoResponse.hist":
+		x.Hist = value.Message().Interface().(*HistoricalInfo)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryHistoricalInfoResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoResponse.hist":
+		if x.Hist == nil {
+			x.Hist = new(HistoricalInfo)
+		}
+		return protoreflect.ValueOfMessage(x.Hist.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryHistoricalInfoResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryHistoricalInfoResponse.hist":
+		m := new(HistoricalInfo)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryHistoricalInfoResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryHistoricalInfoResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryHistoricalInfoResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryHistoricalInfoResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryHistoricalInfoResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryHistoricalInfoResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryHistoricalInfoResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryHistoricalInfoResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryHistoricalInfoResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Hist != nil {
+			l = options.Size(x.Hist)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryHistoricalInfoResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Hist != nil {
+			encoded, err := options.Marshal(x.Hist)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryHistoricalInfoResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHistoricalInfoResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHistoricalInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Hist", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Hist == nil {
+					x.Hist = &HistoricalInfo{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Hist); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryPoolRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryPoolRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryPoolRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryPoolRequest)(nil)
+
+type fastReflection_QueryPoolRequest QueryPoolRequest
+
+func (x *QueryPoolRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPoolRequest)(x)
+}
+
+func (x *QueryPoolRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryPoolRequest_messageType fastReflection_QueryPoolRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPoolRequest_messageType{}
+
+type fastReflection_QueryPoolRequest_messageType struct{}
+
+func (x fastReflection_QueryPoolRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPoolRequest)(nil)
+}
+func (x fastReflection_QueryPoolRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPoolRequest)
+}
+func (x fastReflection_QueryPoolRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoolRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryPoolRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoolRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryPoolRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPoolRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryPoolRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryPoolRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryPoolRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryPoolRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryPoolRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryPoolRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryPoolRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryPoolRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryPoolRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryPoolRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryPoolRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryPoolRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryPoolRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryPoolRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryPoolRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryPoolRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryPoolRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryPoolRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryPoolRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryPoolRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoolRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoolRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryPoolResponse      protoreflect.MessageDescriptor
+	fd_QueryPoolResponse_pool protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryPoolResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryPoolResponse")
+	fd_QueryPoolResponse_pool = md_QueryPoolResponse.Fields().ByName("pool")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryPoolResponse)(nil)
+
+type fastReflection_QueryPoolResponse QueryPoolResponse
+
+func (x *QueryPoolResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPoolResponse)(x)
+}
+
+func (x *QueryPoolResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryPoolResponse_messageType fastReflection_QueryPoolResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPoolResponse_messageType{}
+
+type fastReflection_QueryPoolResponse_messageType struct{}
+
+func (x fastReflection_QueryPoolResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPoolResponse)(nil)
+}
+func (x fastReflection_QueryPoolResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPoolResponse)
+}
+func (x fastReflection_QueryPoolResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoolResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryPoolResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoolResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryPoolResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPoolResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryPoolResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryPoolResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryPoolResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryPoolResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryPoolResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Pool != nil {
+		value := protoreflect.ValueOfMessage(x.Pool.ProtoReflect())
+		if !f(fd_QueryPoolResponse_pool, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryPoolResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryPoolResponse.pool":
+		return x.Pool != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryPoolResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryPoolResponse.pool":
+		x.Pool = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryPoolResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryPoolResponse.pool":
+		value := x.Pool
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryPoolResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryPoolResponse.pool":
+		x.Pool = value.Message().Interface().(*Pool)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryPoolResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryPoolResponse.pool":
+		if x.Pool == nil {
+			x.Pool = new(Pool)
+		}
+		return protoreflect.ValueOfMessage(x.Pool.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryPoolResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryPoolResponse.pool":
+		m := new(Pool)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryPoolResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryPoolResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryPoolResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryPoolResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryPoolResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryPoolResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryPoolResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryPoolResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryPoolResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Pool != nil {
+			l = options.Size(x.Pool)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryPoolResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Pool != nil {
+			encoded, err := options.Marshal(x.Pool)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryPoolResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoolResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pool", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pool == nil {
+					x.Pool = &Pool{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pool); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryParamsRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryParamsRequest = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryParamsRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsRequest)(nil)
+
+type fastReflection_QueryParamsRequest QueryParamsRequest
+
+func (x *QueryParamsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryParamsRequest)(x)
+}
+
+func (x *QueryParamsRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryParamsRequest_messageType fastReflection_QueryParamsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsRequest_messageType{}
+
+type fastReflection_QueryParamsRequest_messageType struct{}
+
+func (x fastReflection_QueryParamsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryParamsRequest)(nil)
+}
+func (x fastReflection_QueryParamsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryParamsRequest)
+}
+func (x fastReflection_QueryParamsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParamsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParamsRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryParamsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryParamsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryParamsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryParamsRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryParamsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryParamsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryParamsRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryParamsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryParamsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryParamsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryParamsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsRequest"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryParamsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryParamsRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryParamsRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryParamsRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryParamsRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryParamsRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryParamsRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryParamsRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryParamsRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryParamsResponse        protoreflect.MessageDescriptor
+	fd_QueryParamsResponse_params protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_query_proto_init()
+	md_QueryParamsResponse = File_cosmos_staking_v1beta1_query_proto.Messages().ByName("QueryParamsResponse")
+	fd_QueryParamsResponse_params = md_QueryParamsResponse.Fields().ByName("params")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryParamsResponse)(nil)
+
+type fastReflection_QueryParamsResponse QueryParamsResponse
+
+func (x *QueryParamsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryParamsResponse)(x)
+}
+
+func (x *QueryParamsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryParamsResponse_messageType fastReflection_QueryParamsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParamsResponse_messageType{}
+
+type fastReflection_QueryParamsResponse_messageType struct{}
+
+func (x fastReflection_QueryParamsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryParamsResponse)(nil)
+}
+func (x fastReflection_QueryParamsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryParamsResponse)
+}
+func (x fastReflection_QueryParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParamsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryParamsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParamsResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryParamsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryParamsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryParamsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryParamsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryParamsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryParamsResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Params != nil {
+		value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+		if !f(fd_QueryParamsResponse_params, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryParamsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryParamsResponse.params":
+		return x.Params != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryParamsResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryParamsResponse.params":
+		x.Params = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.QueryParamsResponse.params":
+		value := x.Params
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryParamsResponse.params":
+		x.Params = value.Message().Interface().(*Params)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryParamsResponse.params":
+		if x.Params == nil {
+			x.Params = new(Params)
+		}
+		return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.QueryParamsResponse.params":
+		m := new(Params)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.QueryParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.QueryParamsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.QueryParamsResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryParamsResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryParamsResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryParamsResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryParamsResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryParamsResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Params != nil {
+			l = options.Size(x.Params)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryParamsResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Params != nil {
+			encoded, err := options.Marshal(x.Params)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryParamsResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Params == nil {
+					x.Params = &Params{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Params); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.0
+// 	protoc        (unknown)
+// source: cosmos/staking/v1beta1/query.proto
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// QueryValidatorsRequest is request type for Query/Validators RPC method.
+type QueryValidatorsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// status enables to query for validators matching a given status.
+	Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	// pagination defines an optional pagination for the request.
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryValidatorsRequest) Reset() {
+	*x = QueryValidatorsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryValidatorsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryValidatorsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryValidatorsRequest.ProtoReflect.Descriptor instead.
+func (*QueryValidatorsRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *QueryValidatorsRequest) GetStatus() string {
+	if x != nil {
+		return x.Status
+	}
+	return ""
+}
+
+func (x *QueryValidatorsRequest) GetPagination() *v1beta1.PageRequest {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryValidatorsResponse is response type for the Query/Validators RPC method
+type QueryValidatorsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// validators contains all the queried validators.
+	Validators []*Validator `protobuf:"bytes,1,rep,name=validators,proto3" json:"validators,omitempty"`
+	// pagination defines the pagination in the response.
+	Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryValidatorsResponse) Reset() {
+	*x = QueryValidatorsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryValidatorsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryValidatorsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryValidatorsResponse.ProtoReflect.Descriptor instead.
+func (*QueryValidatorsResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *QueryValidatorsResponse) GetValidators() []*Validator {
+	if x != nil {
+		return x.Validators
+	}
+	return nil
+}
+
+func (x *QueryValidatorsResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryValidatorRequest is response type for the Query/Validator RPC method
+type QueryValidatorRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// validator_addr defines the validator address to query for.
+	ValidatorAddr string `protobuf:"bytes,1,opt,name=validator_addr,json=validatorAddr,proto3" json:"validator_addr,omitempty"`
+}
+
+func (x *QueryValidatorRequest) Reset() {
+	*x = QueryValidatorRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryValidatorRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryValidatorRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryValidatorRequest.ProtoReflect.Descriptor instead.
+func (*QueryValidatorRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *QueryValidatorRequest) GetValidatorAddr() string {
+	if x != nil {
+		return x.ValidatorAddr
+	}
+	return ""
+}
+
+// QueryValidatorResponse is response type for the Query/Validator RPC method
+type QueryValidatorResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// validator defines the validator info.
+	Validator *Validator `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator,omitempty"`
+}
+
+func (x *QueryValidatorResponse) Reset() {
+	*x = QueryValidatorResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryValidatorResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryValidatorResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryValidatorResponse.ProtoReflect.Descriptor instead.
+func (*QueryValidatorResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *QueryValidatorResponse) GetValidator() *Validator {
+	if x != nil {
+		return x.Validator
+	}
+	return nil
+}
+
+// QueryValidatorDelegationsRequest is request type for the
+// Query/ValidatorDelegations RPC method
+type QueryValidatorDelegationsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// validator_addr defines the validator address to query for.
+	ValidatorAddr string `protobuf:"bytes,1,opt,name=validator_addr,json=validatorAddr,proto3" json:"validator_addr,omitempty"`
+	// pagination defines an optional pagination for the request.
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryValidatorDelegationsRequest) Reset() {
+	*x = QueryValidatorDelegationsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryValidatorDelegationsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryValidatorDelegationsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryValidatorDelegationsRequest.ProtoReflect.Descriptor instead.
+func (*QueryValidatorDelegationsRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *QueryValidatorDelegationsRequest) GetValidatorAddr() string {
+	if x != nil {
+		return x.ValidatorAddr
+	}
+	return ""
+}
+
+func (x *QueryValidatorDelegationsRequest) GetPagination() *v1beta1.PageRequest {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryValidatorDelegationsResponse is response type for the
+// Query/ValidatorDelegations RPC method
+type QueryValidatorDelegationsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	DelegationResponses []*DelegationResponse `protobuf:"bytes,1,rep,name=delegation_responses,json=delegationResponses,proto3" json:"delegation_responses,omitempty"`
+	// pagination defines the pagination in the response.
+	Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryValidatorDelegationsResponse) Reset() {
+	*x = QueryValidatorDelegationsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryValidatorDelegationsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryValidatorDelegationsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryValidatorDelegationsResponse.ProtoReflect.Descriptor instead.
+func (*QueryValidatorDelegationsResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *QueryValidatorDelegationsResponse) GetDelegationResponses() []*DelegationResponse {
+	if x != nil {
+		return x.DelegationResponses
+	}
+	return nil
+}
+
+func (x *QueryValidatorDelegationsResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryValidatorUnbondingDelegationsRequest is required type for the
+// Query/ValidatorUnbondingDelegations RPC method
+type QueryValidatorUnbondingDelegationsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// validator_addr defines the validator address to query for.
+	ValidatorAddr string `protobuf:"bytes,1,opt,name=validator_addr,json=validatorAddr,proto3" json:"validator_addr,omitempty"`
+	// pagination defines an optional pagination for the request.
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryValidatorUnbondingDelegationsRequest) Reset() {
+	*x = QueryValidatorUnbondingDelegationsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryValidatorUnbondingDelegationsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryValidatorUnbondingDelegationsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryValidatorUnbondingDelegationsRequest.ProtoReflect.Descriptor instead.
+func (*QueryValidatorUnbondingDelegationsRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *QueryValidatorUnbondingDelegationsRequest) GetValidatorAddr() string {
+	if x != nil {
+		return x.ValidatorAddr
+	}
+	return ""
+}
+
+func (x *QueryValidatorUnbondingDelegationsRequest) GetPagination() *v1beta1.PageRequest {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryValidatorUnbondingDelegationsResponse is response type for the
+// Query/ValidatorUnbondingDelegations RPC method.
+type QueryValidatorUnbondingDelegationsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	UnbondingResponses []*UnbondingDelegation `protobuf:"bytes,1,rep,name=unbonding_responses,json=unbondingResponses,proto3" json:"unbonding_responses,omitempty"`
+	// pagination defines the pagination in the response.
+	Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryValidatorUnbondingDelegationsResponse) Reset() {
+	*x = QueryValidatorUnbondingDelegationsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryValidatorUnbondingDelegationsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryValidatorUnbondingDelegationsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryValidatorUnbondingDelegationsResponse.ProtoReflect.Descriptor instead.
+func (*QueryValidatorUnbondingDelegationsResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *QueryValidatorUnbondingDelegationsResponse) GetUnbondingResponses() []*UnbondingDelegation {
+	if x != nil {
+		return x.UnbondingResponses
+	}
+	return nil
+}
+
+func (x *QueryValidatorUnbondingDelegationsResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryDelegationRequest is request type for the Query/Delegation RPC method.
+type QueryDelegationRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegator_addr defines the delegator address to query for.
+	DelegatorAddr string `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3" json:"delegator_addr,omitempty"`
+	// validator_addr defines the validator address to query for.
+	ValidatorAddr string `protobuf:"bytes,2,opt,name=validator_addr,json=validatorAddr,proto3" json:"validator_addr,omitempty"`
+}
+
+func (x *QueryDelegationRequest) Reset() {
+	*x = QueryDelegationRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryDelegationRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryDelegationRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryDelegationRequest.ProtoReflect.Descriptor instead.
+func (*QueryDelegationRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *QueryDelegationRequest) GetDelegatorAddr() string {
+	if x != nil {
+		return x.DelegatorAddr
+	}
+	return ""
+}
+
+func (x *QueryDelegationRequest) GetValidatorAddr() string {
+	if x != nil {
+		return x.ValidatorAddr
+	}
+	return ""
+}
+
+// QueryDelegationResponse is response type for the Query/Delegation RPC method.
+type QueryDelegationResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegation_responses defines the delegation info of a delegation.
+	DelegationResponse *DelegationResponse `protobuf:"bytes,1,opt,name=delegation_response,json=delegationResponse,proto3" json:"delegation_response,omitempty"`
+}
+
+func (x *QueryDelegationResponse) Reset() {
+	*x = QueryDelegationResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryDelegationResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryDelegationResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryDelegationResponse.ProtoReflect.Descriptor instead.
+func (*QueryDelegationResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *QueryDelegationResponse) GetDelegationResponse() *DelegationResponse {
+	if x != nil {
+		return x.DelegationResponse
+	}
+	return nil
+}
+
+// QueryUnbondingDelegationRequest is request type for the
+// Query/UnbondingDelegation RPC method.
+type QueryUnbondingDelegationRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegator_addr defines the delegator address to query for.
+	DelegatorAddr string `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3" json:"delegator_addr,omitempty"`
+	// validator_addr defines the validator address to query for.
+	ValidatorAddr string `protobuf:"bytes,2,opt,name=validator_addr,json=validatorAddr,proto3" json:"validator_addr,omitempty"`
+}
+
+func (x *QueryUnbondingDelegationRequest) Reset() {
+	*x = QueryUnbondingDelegationRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryUnbondingDelegationRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryUnbondingDelegationRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryUnbondingDelegationRequest.ProtoReflect.Descriptor instead.
+func (*QueryUnbondingDelegationRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *QueryUnbondingDelegationRequest) GetDelegatorAddr() string {
+	if x != nil {
+		return x.DelegatorAddr
+	}
+	return ""
+}
+
+func (x *QueryUnbondingDelegationRequest) GetValidatorAddr() string {
+	if x != nil {
+		return x.ValidatorAddr
+	}
+	return ""
+}
+
+// QueryDelegationResponse is response type for the Query/UnbondingDelegation
+// RPC method.
+type QueryUnbondingDelegationResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// unbond defines the unbonding information of a delegation.
+	Unbond *UnbondingDelegation `protobuf:"bytes,1,opt,name=unbond,proto3" json:"unbond,omitempty"`
+}
+
+func (x *QueryUnbondingDelegationResponse) Reset() {
+	*x = QueryUnbondingDelegationResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryUnbondingDelegationResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryUnbondingDelegationResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryUnbondingDelegationResponse.ProtoReflect.Descriptor instead.
+func (*QueryUnbondingDelegationResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *QueryUnbondingDelegationResponse) GetUnbond() *UnbondingDelegation {
+	if x != nil {
+		return x.Unbond
+	}
+	return nil
+}
+
+// QueryDelegatorDelegationsRequest is request type for the
+// Query/DelegatorDelegations RPC method.
+type QueryDelegatorDelegationsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegator_addr defines the delegator address to query for.
+	DelegatorAddr string `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3" json:"delegator_addr,omitempty"`
+	// pagination defines an optional pagination for the request.
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryDelegatorDelegationsRequest) Reset() {
+	*x = QueryDelegatorDelegationsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryDelegatorDelegationsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryDelegatorDelegationsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryDelegatorDelegationsRequest.ProtoReflect.Descriptor instead.
+func (*QueryDelegatorDelegationsRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *QueryDelegatorDelegationsRequest) GetDelegatorAddr() string {
+	if x != nil {
+		return x.DelegatorAddr
+	}
+	return ""
+}
+
+func (x *QueryDelegatorDelegationsRequest) GetPagination() *v1beta1.PageRequest {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryDelegatorDelegationsResponse is response type for the
+// Query/DelegatorDelegations RPC method.
+type QueryDelegatorDelegationsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegation_responses defines all the delegations' info of a delegator.
+	DelegationResponses []*DelegationResponse `protobuf:"bytes,1,rep,name=delegation_responses,json=delegationResponses,proto3" json:"delegation_responses,omitempty"`
+	// pagination defines the pagination in the response.
+	Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryDelegatorDelegationsResponse) Reset() {
+	*x = QueryDelegatorDelegationsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryDelegatorDelegationsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryDelegatorDelegationsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryDelegatorDelegationsResponse.ProtoReflect.Descriptor instead.
+func (*QueryDelegatorDelegationsResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *QueryDelegatorDelegationsResponse) GetDelegationResponses() []*DelegationResponse {
+	if x != nil {
+		return x.DelegationResponses
+	}
+	return nil
+}
+
+func (x *QueryDelegatorDelegationsResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryDelegatorUnbondingDelegationsRequest is request type for the
+// Query/DelegatorUnbondingDelegations RPC method.
+type QueryDelegatorUnbondingDelegationsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegator_addr defines the delegator address to query for.
+	DelegatorAddr string `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3" json:"delegator_addr,omitempty"`
+	// pagination defines an optional pagination for the request.
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryDelegatorUnbondingDelegationsRequest) Reset() {
+	*x = QueryDelegatorUnbondingDelegationsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryDelegatorUnbondingDelegationsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryDelegatorUnbondingDelegationsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryDelegatorUnbondingDelegationsRequest.ProtoReflect.Descriptor instead.
+func (*QueryDelegatorUnbondingDelegationsRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *QueryDelegatorUnbondingDelegationsRequest) GetDelegatorAddr() string {
+	if x != nil {
+		return x.DelegatorAddr
+	}
+	return ""
+}
+
+func (x *QueryDelegatorUnbondingDelegationsRequest) GetPagination() *v1beta1.PageRequest {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryUnbondingDelegatorDelegationsResponse is response type for the
+// Query/UnbondingDelegatorDelegations RPC method.
+type QueryDelegatorUnbondingDelegationsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	UnbondingResponses []*UnbondingDelegation `protobuf:"bytes,1,rep,name=unbonding_responses,json=unbondingResponses,proto3" json:"unbonding_responses,omitempty"`
+	// pagination defines the pagination in the response.
+	Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryDelegatorUnbondingDelegationsResponse) Reset() {
+	*x = QueryDelegatorUnbondingDelegationsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryDelegatorUnbondingDelegationsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryDelegatorUnbondingDelegationsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryDelegatorUnbondingDelegationsResponse.ProtoReflect.Descriptor instead.
+func (*QueryDelegatorUnbondingDelegationsResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *QueryDelegatorUnbondingDelegationsResponse) GetUnbondingResponses() []*UnbondingDelegation {
+	if x != nil {
+		return x.UnbondingResponses
+	}
+	return nil
+}
+
+func (x *QueryDelegatorUnbondingDelegationsResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryRedelegationsRequest is request type for the Query/Redelegations RPC
+// method.
+type QueryRedelegationsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegator_addr defines the delegator address to query for.
+	DelegatorAddr string `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3" json:"delegator_addr,omitempty"`
+	// src_validator_addr defines the validator address to redelegate from.
+	SrcValidatorAddr string `protobuf:"bytes,2,opt,name=src_validator_addr,json=srcValidatorAddr,proto3" json:"src_validator_addr,omitempty"`
+	// dst_validator_addr defines the validator address to redelegate to.
+	DstValidatorAddr string `protobuf:"bytes,3,opt,name=dst_validator_addr,json=dstValidatorAddr,proto3" json:"dst_validator_addr,omitempty"`
+	// pagination defines an optional pagination for the request.
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,4,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryRedelegationsRequest) Reset() {
+	*x = QueryRedelegationsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryRedelegationsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryRedelegationsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryRedelegationsRequest.ProtoReflect.Descriptor instead.
+func (*QueryRedelegationsRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *QueryRedelegationsRequest) GetDelegatorAddr() string {
+	if x != nil {
+		return x.DelegatorAddr
+	}
+	return ""
+}
+
+func (x *QueryRedelegationsRequest) GetSrcValidatorAddr() string {
+	if x != nil {
+		return x.SrcValidatorAddr
+	}
+	return ""
+}
+
+func (x *QueryRedelegationsRequest) GetDstValidatorAddr() string {
+	if x != nil {
+		return x.DstValidatorAddr
+	}
+	return ""
+}
+
+func (x *QueryRedelegationsRequest) GetPagination() *v1beta1.PageRequest {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryRedelegationsResponse is response type for the Query/Redelegations RPC
+// method.
+type QueryRedelegationsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RedelegationResponses []*RedelegationResponse `protobuf:"bytes,1,rep,name=redelegation_responses,json=redelegationResponses,proto3" json:"redelegation_responses,omitempty"`
+	// pagination defines the pagination in the response.
+	Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryRedelegationsResponse) Reset() {
+	*x = QueryRedelegationsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryRedelegationsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryRedelegationsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryRedelegationsResponse.ProtoReflect.Descriptor instead.
+func (*QueryRedelegationsResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *QueryRedelegationsResponse) GetRedelegationResponses() []*RedelegationResponse {
+	if x != nil {
+		return x.RedelegationResponses
+	}
+	return nil
+}
+
+func (x *QueryRedelegationsResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryDelegatorValidatorsRequest is request type for the
+// Query/DelegatorValidators RPC method.
+type QueryDelegatorValidatorsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegator_addr defines the delegator address to query for.
+	DelegatorAddr string `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3" json:"delegator_addr,omitempty"`
+	// pagination defines an optional pagination for the request.
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryDelegatorValidatorsRequest) Reset() {
+	*x = QueryDelegatorValidatorsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryDelegatorValidatorsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryDelegatorValidatorsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryDelegatorValidatorsRequest.ProtoReflect.Descriptor instead.
+func (*QueryDelegatorValidatorsRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *QueryDelegatorValidatorsRequest) GetDelegatorAddr() string {
+	if x != nil {
+		return x.DelegatorAddr
+	}
+	return ""
+}
+
+func (x *QueryDelegatorValidatorsRequest) GetPagination() *v1beta1.PageRequest {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryDelegatorValidatorsResponse is response type for the
+// Query/DelegatorValidators RPC method.
+type QueryDelegatorValidatorsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// validators defines the validators' info of a delegator.
+	Validators []*Validator `protobuf:"bytes,1,rep,name=validators,proto3" json:"validators,omitempty"`
+	// pagination defines the pagination in the response.
+	Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryDelegatorValidatorsResponse) Reset() {
+	*x = QueryDelegatorValidatorsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryDelegatorValidatorsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryDelegatorValidatorsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryDelegatorValidatorsResponse.ProtoReflect.Descriptor instead.
+func (*QueryDelegatorValidatorsResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *QueryDelegatorValidatorsResponse) GetValidators() []*Validator {
+	if x != nil {
+		return x.Validators
+	}
+	return nil
+}
+
+func (x *QueryDelegatorValidatorsResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+// QueryDelegatorValidatorRequest is request type for the
+// Query/DelegatorValidator RPC method.
+type QueryDelegatorValidatorRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegator_addr defines the delegator address to query for.
+	DelegatorAddr string `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3" json:"delegator_addr,omitempty"`
+	// validator_addr defines the validator address to query for.
+	ValidatorAddr string `protobuf:"bytes,2,opt,name=validator_addr,json=validatorAddr,proto3" json:"validator_addr,omitempty"`
+}
+
+func (x *QueryDelegatorValidatorRequest) Reset() {
+	*x = QueryDelegatorValidatorRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryDelegatorValidatorRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryDelegatorValidatorRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryDelegatorValidatorRequest.ProtoReflect.Descriptor instead.
+func (*QueryDelegatorValidatorRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *QueryDelegatorValidatorRequest) GetDelegatorAddr() string {
+	if x != nil {
+		return x.DelegatorAddr
+	}
+	return ""
+}
+
+func (x *QueryDelegatorValidatorRequest) GetValidatorAddr() string {
+	if x != nil {
+		return x.ValidatorAddr
+	}
+	return ""
+}
+
+// QueryDelegatorValidatorResponse response type for the
+// Query/DelegatorValidator RPC method.
+type QueryDelegatorValidatorResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// validator defines the validator info.
+	Validator *Validator `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator,omitempty"`
+}
+
+func (x *QueryDelegatorValidatorResponse) Reset() {
+	*x = QueryDelegatorValidatorResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryDelegatorValidatorResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryDelegatorValidatorResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryDelegatorValidatorResponse.ProtoReflect.Descriptor instead.
+func (*QueryDelegatorValidatorResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *QueryDelegatorValidatorResponse) GetValidator() *Validator {
+	if x != nil {
+		return x.Validator
+	}
+	return nil
+}
+
+// QueryHistoricalInfoRequest is request type for the Query/HistoricalInfo RPC
+// method.
+type QueryHistoricalInfoRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// height defines at which height to query the historical info.
+	Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+}
+
+func (x *QueryHistoricalInfoRequest) Reset() {
+	*x = QueryHistoricalInfoRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryHistoricalInfoRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryHistoricalInfoRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryHistoricalInfoRequest.ProtoReflect.Descriptor instead.
+func (*QueryHistoricalInfoRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *QueryHistoricalInfoRequest) GetHeight() int64 {
+	if x != nil {
+		return x.Height
+	}
+	return 0
+}
+
+// QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC
+// method.
+type QueryHistoricalInfoResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// hist defines the historical info at the given height.
+	Hist *HistoricalInfo `protobuf:"bytes,1,opt,name=hist,proto3" json:"hist,omitempty"`
+}
+
+func (x *QueryHistoricalInfoResponse) Reset() {
+	*x = QueryHistoricalInfoResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryHistoricalInfoResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryHistoricalInfoResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryHistoricalInfoResponse.ProtoReflect.Descriptor instead.
+func (*QueryHistoricalInfoResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{23}
+}
+
+func (x *QueryHistoricalInfoResponse) GetHist() *HistoricalInfo {
+	if x != nil {
+		return x.Hist
+	}
+	return nil
+}
+
+// QueryPoolRequest is request type for the Query/Pool RPC method.
+type QueryPoolRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *QueryPoolRequest) Reset() {
+	*x = QueryPoolRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryPoolRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryPoolRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryPoolRequest.ProtoReflect.Descriptor instead.
+func (*QueryPoolRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{24}
+}
+
+// QueryPoolResponse is response type for the Query/Pool RPC method.
+type QueryPoolResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// pool defines the pool info.
+	Pool *Pool `protobuf:"bytes,1,opt,name=pool,proto3" json:"pool,omitempty"`
+}
+
+func (x *QueryPoolResponse) Reset() {
+	*x = QueryPoolResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryPoolResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryPoolResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryPoolResponse.ProtoReflect.Descriptor instead.
+func (*QueryPoolResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *QueryPoolResponse) GetPool() *Pool {
+	if x != nil {
+		return x.Pool
+	}
+	return nil
+}
+
+// QueryParamsRequest is request type for the Query/Params RPC method.
+type QueryParamsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *QueryParamsRequest) Reset() {
+	*x = QueryParamsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryParamsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryParamsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryParamsRequest.ProtoReflect.Descriptor instead.
+func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{26}
+}
+
+// QueryParamsResponse is response type for the Query/Params RPC method.
+type QueryParamsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// params holds all the parameters of this module.
+	Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
+}
+
+func (x *QueryParamsResponse) Reset() {
+	*x = QueryParamsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_query_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryParamsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryParamsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryParamsResponse.ProtoReflect.Descriptor instead.
+func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_query_proto_rawDescGZIP(), []int{27}
+}
+
+func (x *QueryParamsResponse) GetParams() *Params {
+	if x != nil {
+		return x.Params
+	}
+	return nil
+}
+
+var File_cosmos_staking_v1beta1_query_proto protoreflect.FileDescriptor
+
+var file_cosmos_staking_v1beta1_query_proto_rawDesc = []byte{
+	0x0a, 0x22, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x1a, 0x2a, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2f,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2f, 0x76, 0x31, 0x2f, 0x71,
+	0x75, 0x65, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e,
+	0x6f, 0x2f, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x78, 0x0a,
+	0x16, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,
+	0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12,
+	0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73,
+	0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e,
+	0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67,
+	0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xb0, 0x01, 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00,
+	0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62,
+	0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a,
+	0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x61, 0x0a, 0x15, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x12, 0x48, 0x0a, 0x0e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d,
+	0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
+	0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0d,
+	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x22, 0x64, 0x0a,
+	0x16, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65,
+	0x74, 0x61, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x42, 0x09, 0xc8,
+	0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x22, 0xb4, 0x01, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x48, 0x0a, 0x0e, 0x76, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x52, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64,
+	0x64, 0x72, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a,
+	0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xed, 0x01, 0x0a, 0x21, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x44, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x7f, 0x0a, 0x14, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a,
+	0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x20, 0xc8, 0xde, 0x1f, 0x00,
+	0xaa, 0xdf, 0x1f, 0x13, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x13, 0x64, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62,
+	0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a,
+	0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xbd, 0x01, 0x0a, 0x29, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x6e, 0x62,
+	0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x48, 0x0a, 0x0e, 0x76, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x52, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64,
+	0x64, 0x72, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a,
+	0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xde, 0x01, 0x0a, 0x2a, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x6e, 0x62,
+	0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x67, 0x0a, 0x13, 0x75, 0x6e, 0x62,
+	0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73,
+	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e,
+	0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x12,
+	0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52,
+	0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xad, 0x01, 0x0a, 0x16,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x0e, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18,
+	0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0d, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x12, 0x48, 0x0a, 0x0e, 0x76, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42,
+	0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x52, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64,
+	0x72, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x76, 0x0a, 0x17, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5b, 0x0a, 0x13, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52,
+	0x12, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0xb6, 0x01, 0x0a, 0x1f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x62,
+	0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x0e, 0x64, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42,
+	0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0d, 0x64, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x12, 0x48, 0x0a, 0x0e, 0x76, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x52, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64,
+	0x64, 0x72, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x72, 0x0a, 0x20,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x4e, 0x0a, 0x06, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e,
+	0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64,
+	0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8,
+	0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64,
+	0x22, 0xb5, 0x01, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x6f, 0x72, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x0e, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2,
+	0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
+	0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0d, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76,
+	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x08,
+	0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xd6, 0x01, 0x0a, 0x21, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x44, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68,
+	0x0a, 0x14, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7,
+	0xb0, 0x2a, 0x01, 0x52, 0x13, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69,
+	0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79,
+	0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x22, 0xbe, 0x01, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x6f, 0x72, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x3f, 0x0a, 0x0e, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x52, 0x0d, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72,
+	0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61,
+	0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61,
+	0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0,
+	0x1f, 0x00, 0x22, 0xde, 0x01, 0x0a, 0x2a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x67, 0x0a, 0x13, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x72,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b,
+	0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e,
+	0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f,
+	0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x12, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e,
+	0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61,
+	0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
+	0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65,
+	0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x22, 0xd0, 0x02, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x64,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x12, 0x3f, 0x0a, 0x0e, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61,
+	0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x52, 0x0d, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64,
+	0x64, 0x72, 0x12, 0x4f, 0x0a, 0x12, 0x73, 0x72, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21,
+	0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x52, 0x10, 0x73, 0x72, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41,
+	0x64, 0x64, 0x72, 0x12, 0x4f, 0x0a, 0x12, 0x64, 0x73, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42,
+	0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x52, 0x10, 0x64, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x41, 0x64, 0x64, 0x72, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x08, 0x88, 0xa0,
+	0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xd5, 0x01, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x16, 0x72, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x52,
+	0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x15,
+	0x72, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xb4,
+	0x01, 0x0a, 0x1f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f,
+	0x72, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x3f, 0x0a, 0x0e, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f,
+	0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x52, 0x0d, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41,
+	0x64, 0x64, 0x72, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65,
+	0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52,
+	0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x08, 0x88, 0xa0, 0x1f,
+	0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xb9, 0x01, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
+	0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x0a, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21,
+	0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
+	0x72, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69,
+	0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79,
+	0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x22, 0xb5, 0x01, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x6f, 0x72, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x0e, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f,
+	0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4,
+	0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0d, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f,
+	0x72, 0x41, 0x64, 0x64, 0x72, 0x12, 0x48, 0x0a, 0x0e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2,
+	0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x52, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x3a,
+	0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x6d, 0x0a, 0x1f, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x09,
+	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x21, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x6f, 0x72, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x09, 0x76,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x34, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x59,
+	0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61,
+	0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a,
+	0x04, 0x68, 0x69, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0x2e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x49,
+	0x6e, 0x66, 0x6f, 0x52, 0x04, 0x68, 0x69, 0x73, 0x74, 0x22, 0x12, 0x0a, 0x10, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x50, 0x0a,
+	0x11, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x70, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x1c, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e,
+	0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x6f, 0x6f, 0x6c, 0x42, 0x09,
+	0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x04, 0x70, 0x6f, 0x6f, 0x6c, 0x22,
+	0x14, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x58, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61,
+	0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x41, 0x0a, 0x06,
+	0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x09, 0xc8, 0xde,
+	0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x32,
+	0xb0, 0x16, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x9e, 0x01, 0x0a, 0x0a, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x2e, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0x88, 0xe7, 0xb0, 0x2a, 0x01,
+	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x24, 0x12, 0x22, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f,
+	0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f,
+	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x12, 0xac, 0x01, 0x0a, 0x09, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x2d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x40, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3,
+	0xe4, 0x93, 0x02, 0x35, 0x12, 0x33, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74,
+	0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x2f, 0x7b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x7d, 0x12, 0xd9, 0x01, 0x0a, 0x14, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x12, 0x38, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b,
+	0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x39, 0x2e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4c, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3,
+	0xe4, 0x93, 0x02, 0x41, 0x12, 0x3f, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74,
+	0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x2f, 0x7b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x7d, 0x2f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0xfe, 0x01, 0x0a, 0x1d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x41, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x55,
+	0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x42, 0x2e, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65,
+	0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x6f, 0x72, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x56,
+	0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4b, 0x12, 0x49, 0x2f, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x2f,
+	0x7b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x7d,
+	0x2f, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0xcc, 0x01, 0x0a, 0x0a, 0x44, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5d, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x52, 0x12, 0x50, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x2f, 0x7b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x7d, 0x2f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x7b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f,
+	0x61, 0x64, 0x64, 0x72, 0x7d, 0x12, 0xfc, 0x01, 0x0a, 0x13, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64,
+	0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x37, 0x2e,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76,
+	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x62, 0x6f,
+	0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x38, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x72, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x67, 0x12, 0x65, 0x2f,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76,
+	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x73, 0x2f, 0x7b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x7d, 0x2f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x7b,
+	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x7d, 0x2f,
+	0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x12, 0xce, 0x01, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x6f, 0x72, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x38, 0x2e,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76,
+	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x6f, 0x72, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x39, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x44,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x41, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x36, 0x12,
+	0x34, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x7b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f,
+	0x61, 0x64, 0x64, 0x72, 0x7d, 0x12, 0xfe, 0x01, 0x0a, 0x1d, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x6f, 0x72, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x41, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x55,
+	0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x42, 0x2e, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65,
+	0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x6f, 0x72, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x56,
+	0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4b, 0x12, 0x49, 0x2f, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0x2f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x2f,
+	0x7b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x7d,
+	0x2f, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0xc6, 0x01, 0x0a, 0x0d, 0x52, 0x65, 0x64, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x31, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x4e, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x43, 0x12, 0x41, 0x2f, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x73,
+	0x2f, 0x7b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72,
+	0x7d, 0x2f, 0x72, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12,
+	0xd5, 0x01, 0x0a, 0x13, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x37, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x38, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e,
+	0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
+	0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4b, 0x88, 0xe7, 0xb0, 0x2a,
+	0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x40, 0x12, 0x3e, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x2f, 0x7b, 0x64, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x7d, 0x2f, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x12, 0xe3, 0x01, 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x6f, 0x72, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x36,
+	0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x5c, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x51, 0x12, 0x4f, 0x2f, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x73,
+	0x2f, 0x7b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72,
+	0x7d, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x2f, 0x7b, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x7d, 0x12, 0xb8, 0x01,
+	0x0a, 0x0e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f,
+	0x12, 0x32, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e,
+	0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48,
+	0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74,
+	0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x49, 0x6e, 0x66,
+	0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3d, 0x88, 0xe7, 0xb0, 0x2a, 0x01,
+	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x32, 0x12, 0x30, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f,
+	0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f,
+	0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x2f,
+	0x7b, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0x86, 0x01, 0x0a, 0x04, 0x50, 0x6f, 0x6f,
+	0x6c, 0x12, 0x28, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69,
+	0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x29, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x1e, 0x12, 0x1c, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x70, 0x6f, 0x6f,
+	0x6c, 0x12, 0x8e, 0x01, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2a, 0x2e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93,
+	0x02, 0x20, 0x12, 0x1e, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b,
+	0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x70, 0x61, 0x72, 0x61,
+	0x6d, 0x73, 0x42, 0xda, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a,
+	0x36, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70,
+	0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x53, 0x58, 0xaa, 0x02, 0x16,
+	0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x56,
+	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, 0x02, 0x16, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c,
+	0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2,
+	0x02, 0x22, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61,
+	0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x18, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x53,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x62,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cosmos_staking_v1beta1_query_proto_rawDescOnce sync.Once
+	file_cosmos_staking_v1beta1_query_proto_rawDescData = file_cosmos_staking_v1beta1_query_proto_rawDesc
+)
+
+func file_cosmos_staking_v1beta1_query_proto_rawDescGZIP() []byte {
+	file_cosmos_staking_v1beta1_query_proto_rawDescOnce.Do(func() {
+		file_cosmos_staking_v1beta1_query_proto_rawDescData = protoimpl.X.CompressGZIP(file_cosmos_staking_v1beta1_query_proto_rawDescData)
+	})
+	return file_cosmos_staking_v1beta1_query_proto_rawDescData
+}
+
+var file_cosmos_staking_v1beta1_query_proto_msgTypes = make([]protoimpl.MessageInfo, 28)
+var file_cosmos_staking_v1beta1_query_proto_goTypes = []interface{}{
+	(*QueryValidatorsRequest)(nil),                     // 0: cosmos.staking.v1beta1.QueryValidatorsRequest
+	(*QueryValidatorsResponse)(nil),                    // 1: cosmos.staking.v1beta1.QueryValidatorsResponse
+	(*QueryValidatorRequest)(nil),                      // 2: cosmos.staking.v1beta1.QueryValidatorRequest
+	(*QueryValidatorResponse)(nil),                     // 3: cosmos.staking.v1beta1.QueryValidatorResponse
+	(*QueryValidatorDelegationsRequest)(nil),           // 4: cosmos.staking.v1beta1.QueryValidatorDelegationsRequest
+	(*QueryValidatorDelegationsResponse)(nil),          // 5: cosmos.staking.v1beta1.QueryValidatorDelegationsResponse
+	(*QueryValidatorUnbondingDelegationsRequest)(nil),  // 6: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest
+	(*QueryValidatorUnbondingDelegationsResponse)(nil), // 7: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse
+	(*QueryDelegationRequest)(nil),                     // 8: cosmos.staking.v1beta1.QueryDelegationRequest
+	(*QueryDelegationResponse)(nil),                    // 9: cosmos.staking.v1beta1.QueryDelegationResponse
+	(*QueryUnbondingDelegationRequest)(nil),            // 10: cosmos.staking.v1beta1.QueryUnbondingDelegationRequest
+	(*QueryUnbondingDelegationResponse)(nil),           // 11: cosmos.staking.v1beta1.QueryUnbondingDelegationResponse
+	(*QueryDelegatorDelegationsRequest)(nil),           // 12: cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest
+	(*QueryDelegatorDelegationsResponse)(nil),          // 13: cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse
+	(*QueryDelegatorUnbondingDelegationsRequest)(nil),  // 14: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest
+	(*QueryDelegatorUnbondingDelegationsResponse)(nil), // 15: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse
+	(*QueryRedelegationsRequest)(nil),                  // 16: cosmos.staking.v1beta1.QueryRedelegationsRequest
+	(*QueryRedelegationsResponse)(nil),                 // 17: cosmos.staking.v1beta1.QueryRedelegationsResponse
+	(*QueryDelegatorValidatorsRequest)(nil),            // 18: cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest
+	(*QueryDelegatorValidatorsResponse)(nil),           // 19: cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse
+	(*QueryDelegatorValidatorRequest)(nil),             // 20: cosmos.staking.v1beta1.QueryDelegatorValidatorRequest
+	(*QueryDelegatorValidatorResponse)(nil),            // 21: cosmos.staking.v1beta1.QueryDelegatorValidatorResponse
+	(*QueryHistoricalInfoRequest)(nil),                 // 22: cosmos.staking.v1beta1.QueryHistoricalInfoRequest
+	(*QueryHistoricalInfoResponse)(nil),                // 23: cosmos.staking.v1beta1.QueryHistoricalInfoResponse
+	(*QueryPoolRequest)(nil),                           // 24: cosmos.staking.v1beta1.QueryPoolRequest
+	(*QueryPoolResponse)(nil),                          // 25: cosmos.staking.v1beta1.QueryPoolResponse
+	(*QueryParamsRequest)(nil),                         // 26: cosmos.staking.v1beta1.QueryParamsRequest
+	(*QueryParamsResponse)(nil),                        // 27: cosmos.staking.v1beta1.QueryParamsResponse
+	(*v1beta1.PageRequest)(nil),                        // 28: cosmos.base.query.v1beta1.PageRequest
+	(*Validator)(nil),                                  // 29: cosmos.staking.v1beta1.Validator
+	(*v1beta1.PageResponse)(nil),                       // 30: cosmos.base.query.v1beta1.PageResponse
+	(*DelegationResponse)(nil),                         // 31: cosmos.staking.v1beta1.DelegationResponse
+	(*UnbondingDelegation)(nil),                        // 32: cosmos.staking.v1beta1.UnbondingDelegation
+	(*RedelegationResponse)(nil),                       // 33: cosmos.staking.v1beta1.RedelegationResponse
+	(*HistoricalInfo)(nil),                             // 34: cosmos.staking.v1beta1.HistoricalInfo
+	(*Pool)(nil),                                       // 35: cosmos.staking.v1beta1.Pool
+	(*Params)(nil),                                     // 36: cosmos.staking.v1beta1.Params
+}
+var file_cosmos_staking_v1beta1_query_proto_depIdxs = []int32{
+	28, // 0: cosmos.staking.v1beta1.QueryValidatorsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	29, // 1: cosmos.staking.v1beta1.QueryValidatorsResponse.validators:type_name -> cosmos.staking.v1beta1.Validator
+	30, // 2: cosmos.staking.v1beta1.QueryValidatorsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	29, // 3: cosmos.staking.v1beta1.QueryValidatorResponse.validator:type_name -> cosmos.staking.v1beta1.Validator
+	28, // 4: cosmos.staking.v1beta1.QueryValidatorDelegationsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	31, // 5: cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.delegation_responses:type_name -> cosmos.staking.v1beta1.DelegationResponse
+	30, // 6: cosmos.staking.v1beta1.QueryValidatorDelegationsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	28, // 7: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	32, // 8: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.unbonding_responses:type_name -> cosmos.staking.v1beta1.UnbondingDelegation
+	30, // 9: cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	31, // 10: cosmos.staking.v1beta1.QueryDelegationResponse.delegation_response:type_name -> cosmos.staking.v1beta1.DelegationResponse
+	32, // 11: cosmos.staking.v1beta1.QueryUnbondingDelegationResponse.unbond:type_name -> cosmos.staking.v1beta1.UnbondingDelegation
+	28, // 12: cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	31, // 13: cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.delegation_responses:type_name -> cosmos.staking.v1beta1.DelegationResponse
+	30, // 14: cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	28, // 15: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	32, // 16: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.unbonding_responses:type_name -> cosmos.staking.v1beta1.UnbondingDelegation
+	30, // 17: cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	28, // 18: cosmos.staking.v1beta1.QueryRedelegationsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	33, // 19: cosmos.staking.v1beta1.QueryRedelegationsResponse.redelegation_responses:type_name -> cosmos.staking.v1beta1.RedelegationResponse
+	30, // 20: cosmos.staking.v1beta1.QueryRedelegationsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	28, // 21: cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	29, // 22: cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.validators:type_name -> cosmos.staking.v1beta1.Validator
+	30, // 23: cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	29, // 24: cosmos.staking.v1beta1.QueryDelegatorValidatorResponse.validator:type_name -> cosmos.staking.v1beta1.Validator
+	34, // 25: cosmos.staking.v1beta1.QueryHistoricalInfoResponse.hist:type_name -> cosmos.staking.v1beta1.HistoricalInfo
+	35, // 26: cosmos.staking.v1beta1.QueryPoolResponse.pool:type_name -> cosmos.staking.v1beta1.Pool
+	36, // 27: cosmos.staking.v1beta1.QueryParamsResponse.params:type_name -> cosmos.staking.v1beta1.Params
+	0,  // 28: cosmos.staking.v1beta1.Query.Validators:input_type -> cosmos.staking.v1beta1.QueryValidatorsRequest
+	2,  // 29: cosmos.staking.v1beta1.Query.Validator:input_type -> cosmos.staking.v1beta1.QueryValidatorRequest
+	4,  // 30: cosmos.staking.v1beta1.Query.ValidatorDelegations:input_type -> cosmos.staking.v1beta1.QueryValidatorDelegationsRequest
+	6,  // 31: cosmos.staking.v1beta1.Query.ValidatorUnbondingDelegations:input_type -> cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest
+	8,  // 32: cosmos.staking.v1beta1.Query.Delegation:input_type -> cosmos.staking.v1beta1.QueryDelegationRequest
+	10, // 33: cosmos.staking.v1beta1.Query.UnbondingDelegation:input_type -> cosmos.staking.v1beta1.QueryUnbondingDelegationRequest
+	12, // 34: cosmos.staking.v1beta1.Query.DelegatorDelegations:input_type -> cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest
+	14, // 35: cosmos.staking.v1beta1.Query.DelegatorUnbondingDelegations:input_type -> cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest
+	16, // 36: cosmos.staking.v1beta1.Query.Redelegations:input_type -> cosmos.staking.v1beta1.QueryRedelegationsRequest
+	18, // 37: cosmos.staking.v1beta1.Query.DelegatorValidators:input_type -> cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest
+	20, // 38: cosmos.staking.v1beta1.Query.DelegatorValidator:input_type -> cosmos.staking.v1beta1.QueryDelegatorValidatorRequest
+	22, // 39: cosmos.staking.v1beta1.Query.HistoricalInfo:input_type -> cosmos.staking.v1beta1.QueryHistoricalInfoRequest
+	24, // 40: cosmos.staking.v1beta1.Query.Pool:input_type -> cosmos.staking.v1beta1.QueryPoolRequest
+	26, // 41: cosmos.staking.v1beta1.Query.Params:input_type -> cosmos.staking.v1beta1.QueryParamsRequest
+	1,  // 42: cosmos.staking.v1beta1.Query.Validators:output_type -> cosmos.staking.v1beta1.QueryValidatorsResponse
+	3,  // 43: cosmos.staking.v1beta1.Query.Validator:output_type -> cosmos.staking.v1beta1.QueryValidatorResponse
+	5,  // 44: cosmos.staking.v1beta1.Query.ValidatorDelegations:output_type -> cosmos.staking.v1beta1.QueryValidatorDelegationsResponse
+	7,  // 45: cosmos.staking.v1beta1.Query.ValidatorUnbondingDelegations:output_type -> cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse
+	9,  // 46: cosmos.staking.v1beta1.Query.Delegation:output_type -> cosmos.staking.v1beta1.QueryDelegationResponse
+	11, // 47: cosmos.staking.v1beta1.Query.UnbondingDelegation:output_type -> cosmos.staking.v1beta1.QueryUnbondingDelegationResponse
+	13, // 48: cosmos.staking.v1beta1.Query.DelegatorDelegations:output_type -> cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse
+	15, // 49: cosmos.staking.v1beta1.Query.DelegatorUnbondingDelegations:output_type -> cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse
+	17, // 50: cosmos.staking.v1beta1.Query.Redelegations:output_type -> cosmos.staking.v1beta1.QueryRedelegationsResponse
+	19, // 51: cosmos.staking.v1beta1.Query.DelegatorValidators:output_type -> cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse
+	21, // 52: cosmos.staking.v1beta1.Query.DelegatorValidator:output_type -> cosmos.staking.v1beta1.QueryDelegatorValidatorResponse
+	23, // 53: cosmos.staking.v1beta1.Query.HistoricalInfo:output_type -> cosmos.staking.v1beta1.QueryHistoricalInfoResponse
+	25, // 54: cosmos.staking.v1beta1.Query.Pool:output_type -> cosmos.staking.v1beta1.QueryPoolResponse
+	27, // 55: cosmos.staking.v1beta1.Query.Params:output_type -> cosmos.staking.v1beta1.QueryParamsResponse
+	42, // [42:56] is the sub-list for method output_type
+	28, // [28:42] is the sub-list for method input_type
+	28, // [28:28] is the sub-list for extension type_name
+	28, // [28:28] is the sub-list for extension extendee
+	0,  // [0:28] is the sub-list for field type_name
+}
+
+func init() { file_cosmos_staking_v1beta1_query_proto_init() }
+func file_cosmos_staking_v1beta1_query_proto_init() {
+	if File_cosmos_staking_v1beta1_query_proto != nil {
+		return
+	}
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryValidatorsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryValidatorsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryValidatorRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryValidatorResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryValidatorDelegationsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryValidatorDelegationsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryValidatorUnbondingDelegationsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryValidatorUnbondingDelegationsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryDelegationRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryDelegationResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryUnbondingDelegationRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryUnbondingDelegationResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryDelegatorDelegationsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryDelegatorDelegationsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryDelegatorUnbondingDelegationsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryDelegatorUnbondingDelegationsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryRedelegationsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryRedelegationsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryDelegatorValidatorsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryDelegatorValidatorsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryDelegatorValidatorRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryDelegatorValidatorResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryHistoricalInfoRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryHistoricalInfoResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryPoolRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryPoolResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryParamsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_query_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryParamsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cosmos_staking_v1beta1_query_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   28,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_cosmos_staking_v1beta1_query_proto_goTypes,
+		DependencyIndexes: file_cosmos_staking_v1beta1_query_proto_depIdxs,
+		MessageInfos:      file_cosmos_staking_v1beta1_query_proto_msgTypes,
+	}.Build()
+	File_cosmos_staking_v1beta1_query_proto = out.File
+	file_cosmos_staking_v1beta1_query_proto_rawDesc = nil
+	file_cosmos_staking_v1beta1_query_proto_goTypes = nil
+	file_cosmos_staking_v1beta1_query_proto_depIdxs = nil
+}
diff --git a/atomone-api/cosmos/staking/v1beta1/query_grpc.pb.go b/atomone-api/cosmos/staking/v1beta1/query_grpc.pb.go
new file mode 100644
index 000000000000..3ae9b2f5cfc3
--- /dev/null
+++ b/atomone-api/cosmos/staking/v1beta1/query_grpc.pb.go
@@ -0,0 +1,697 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.5.1
+// - protoc             (unknown)
+// source: cosmos/staking/v1beta1/query.proto
+
+package stakingv1beta1
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	Query_Validators_FullMethodName                    = "/cosmos.staking.v1beta1.Query/Validators"
+	Query_Validator_FullMethodName                     = "/cosmos.staking.v1beta1.Query/Validator"
+	Query_ValidatorDelegations_FullMethodName          = "/cosmos.staking.v1beta1.Query/ValidatorDelegations"
+	Query_ValidatorUnbondingDelegations_FullMethodName = "/cosmos.staking.v1beta1.Query/ValidatorUnbondingDelegations"
+	Query_Delegation_FullMethodName                    = "/cosmos.staking.v1beta1.Query/Delegation"
+	Query_UnbondingDelegation_FullMethodName           = "/cosmos.staking.v1beta1.Query/UnbondingDelegation"
+	Query_DelegatorDelegations_FullMethodName          = "/cosmos.staking.v1beta1.Query/DelegatorDelegations"
+	Query_DelegatorUnbondingDelegations_FullMethodName = "/cosmos.staking.v1beta1.Query/DelegatorUnbondingDelegations"
+	Query_Redelegations_FullMethodName                 = "/cosmos.staking.v1beta1.Query/Redelegations"
+	Query_DelegatorValidators_FullMethodName           = "/cosmos.staking.v1beta1.Query/DelegatorValidators"
+	Query_DelegatorValidator_FullMethodName            = "/cosmos.staking.v1beta1.Query/DelegatorValidator"
+	Query_HistoricalInfo_FullMethodName                = "/cosmos.staking.v1beta1.Query/HistoricalInfo"
+	Query_Pool_FullMethodName                          = "/cosmos.staking.v1beta1.Query/Pool"
+	Query_Params_FullMethodName                        = "/cosmos.staking.v1beta1.Query/Params"
+)
+
+// QueryClient is the client API for Query service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+//
+// Query defines the gRPC querier service.
+type QueryClient interface {
+	// Validators queries all validators that match the given status.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	Validators(ctx context.Context, in *QueryValidatorsRequest, opts ...grpc.CallOption) (*QueryValidatorsResponse, error)
+	// Validator queries validator info for given validator address.
+	Validator(ctx context.Context, in *QueryValidatorRequest, opts ...grpc.CallOption) (*QueryValidatorResponse, error)
+	// ValidatorDelegations queries delegate info for given validator.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	ValidatorDelegations(ctx context.Context, in *QueryValidatorDelegationsRequest, opts ...grpc.CallOption) (*QueryValidatorDelegationsResponse, error)
+	// ValidatorUnbondingDelegations queries unbonding delegations of a validator.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	ValidatorUnbondingDelegations(ctx context.Context, in *QueryValidatorUnbondingDelegationsRequest, opts ...grpc.CallOption) (*QueryValidatorUnbondingDelegationsResponse, error)
+	// Delegation queries delegate info for given validator delegator pair.
+	Delegation(ctx context.Context, in *QueryDelegationRequest, opts ...grpc.CallOption) (*QueryDelegationResponse, error)
+	// UnbondingDelegation queries unbonding info for given validator delegator
+	// pair.
+	UnbondingDelegation(ctx context.Context, in *QueryUnbondingDelegationRequest, opts ...grpc.CallOption) (*QueryUnbondingDelegationResponse, error)
+	// DelegatorDelegations queries all delegations of a given delegator address.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	DelegatorDelegations(ctx context.Context, in *QueryDelegatorDelegationsRequest, opts ...grpc.CallOption) (*QueryDelegatorDelegationsResponse, error)
+	// DelegatorUnbondingDelegations queries all unbonding delegations of a given
+	// delegator address.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	DelegatorUnbondingDelegations(ctx context.Context, in *QueryDelegatorUnbondingDelegationsRequest, opts ...grpc.CallOption) (*QueryDelegatorUnbondingDelegationsResponse, error)
+	// Redelegations queries redelegations of given address.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	Redelegations(ctx context.Context, in *QueryRedelegationsRequest, opts ...grpc.CallOption) (*QueryRedelegationsResponse, error)
+	// DelegatorValidators queries all validators info for given delegator
+	// address.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	DelegatorValidators(ctx context.Context, in *QueryDelegatorValidatorsRequest, opts ...grpc.CallOption) (*QueryDelegatorValidatorsResponse, error)
+	// DelegatorValidator queries validator info for given delegator validator
+	// pair.
+	DelegatorValidator(ctx context.Context, in *QueryDelegatorValidatorRequest, opts ...grpc.CallOption) (*QueryDelegatorValidatorResponse, error)
+	// HistoricalInfo queries the historical info for given height.
+	HistoricalInfo(ctx context.Context, in *QueryHistoricalInfoRequest, opts ...grpc.CallOption) (*QueryHistoricalInfoResponse, error)
+	// Pool queries the pool info.
+	Pool(ctx context.Context, in *QueryPoolRequest, opts ...grpc.CallOption) (*QueryPoolResponse, error)
+	// Parameters queries the staking parameters.
+	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
+}
+
+type queryClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewQueryClient(cc grpc.ClientConnInterface) QueryClient {
+	return &queryClient{cc}
+}
+
+func (c *queryClient) Validators(ctx context.Context, in *QueryValidatorsRequest, opts ...grpc.CallOption) (*QueryValidatorsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryValidatorsResponse)
+	err := c.cc.Invoke(ctx, Query_Validators_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) Validator(ctx context.Context, in *QueryValidatorRequest, opts ...grpc.CallOption) (*QueryValidatorResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryValidatorResponse)
+	err := c.cc.Invoke(ctx, Query_Validator_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ValidatorDelegations(ctx context.Context, in *QueryValidatorDelegationsRequest, opts ...grpc.CallOption) (*QueryValidatorDelegationsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryValidatorDelegationsResponse)
+	err := c.cc.Invoke(ctx, Query_ValidatorDelegations_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ValidatorUnbondingDelegations(ctx context.Context, in *QueryValidatorUnbondingDelegationsRequest, opts ...grpc.CallOption) (*QueryValidatorUnbondingDelegationsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryValidatorUnbondingDelegationsResponse)
+	err := c.cc.Invoke(ctx, Query_ValidatorUnbondingDelegations_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) Delegation(ctx context.Context, in *QueryDelegationRequest, opts ...grpc.CallOption) (*QueryDelegationResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryDelegationResponse)
+	err := c.cc.Invoke(ctx, Query_Delegation_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) UnbondingDelegation(ctx context.Context, in *QueryUnbondingDelegationRequest, opts ...grpc.CallOption) (*QueryUnbondingDelegationResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryUnbondingDelegationResponse)
+	err := c.cc.Invoke(ctx, Query_UnbondingDelegation_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) DelegatorDelegations(ctx context.Context, in *QueryDelegatorDelegationsRequest, opts ...grpc.CallOption) (*QueryDelegatorDelegationsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryDelegatorDelegationsResponse)
+	err := c.cc.Invoke(ctx, Query_DelegatorDelegations_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) DelegatorUnbondingDelegations(ctx context.Context, in *QueryDelegatorUnbondingDelegationsRequest, opts ...grpc.CallOption) (*QueryDelegatorUnbondingDelegationsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryDelegatorUnbondingDelegationsResponse)
+	err := c.cc.Invoke(ctx, Query_DelegatorUnbondingDelegations_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) Redelegations(ctx context.Context, in *QueryRedelegationsRequest, opts ...grpc.CallOption) (*QueryRedelegationsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryRedelegationsResponse)
+	err := c.cc.Invoke(ctx, Query_Redelegations_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) DelegatorValidators(ctx context.Context, in *QueryDelegatorValidatorsRequest, opts ...grpc.CallOption) (*QueryDelegatorValidatorsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryDelegatorValidatorsResponse)
+	err := c.cc.Invoke(ctx, Query_DelegatorValidators_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) DelegatorValidator(ctx context.Context, in *QueryDelegatorValidatorRequest, opts ...grpc.CallOption) (*QueryDelegatorValidatorResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryDelegatorValidatorResponse)
+	err := c.cc.Invoke(ctx, Query_DelegatorValidator_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) HistoricalInfo(ctx context.Context, in *QueryHistoricalInfoRequest, opts ...grpc.CallOption) (*QueryHistoricalInfoResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryHistoricalInfoResponse)
+	err := c.cc.Invoke(ctx, Query_HistoricalInfo_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) Pool(ctx context.Context, in *QueryPoolRequest, opts ...grpc.CallOption) (*QueryPoolResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryPoolResponse)
+	err := c.cc.Invoke(ctx, Query_Pool_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(QueryParamsResponse)
+	err := c.cc.Invoke(ctx, Query_Params_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// QueryServer is the server API for Query service.
+// All implementations must embed UnimplementedQueryServer
+// for forward compatibility.
+//
+// Query defines the gRPC querier service.
+type QueryServer interface {
+	// Validators queries all validators that match the given status.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	Validators(context.Context, *QueryValidatorsRequest) (*QueryValidatorsResponse, error)
+	// Validator queries validator info for given validator address.
+	Validator(context.Context, *QueryValidatorRequest) (*QueryValidatorResponse, error)
+	// ValidatorDelegations queries delegate info for given validator.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	ValidatorDelegations(context.Context, *QueryValidatorDelegationsRequest) (*QueryValidatorDelegationsResponse, error)
+	// ValidatorUnbondingDelegations queries unbonding delegations of a validator.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	ValidatorUnbondingDelegations(context.Context, *QueryValidatorUnbondingDelegationsRequest) (*QueryValidatorUnbondingDelegationsResponse, error)
+	// Delegation queries delegate info for given validator delegator pair.
+	Delegation(context.Context, *QueryDelegationRequest) (*QueryDelegationResponse, error)
+	// UnbondingDelegation queries unbonding info for given validator delegator
+	// pair.
+	UnbondingDelegation(context.Context, *QueryUnbondingDelegationRequest) (*QueryUnbondingDelegationResponse, error)
+	// DelegatorDelegations queries all delegations of a given delegator address.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	DelegatorDelegations(context.Context, *QueryDelegatorDelegationsRequest) (*QueryDelegatorDelegationsResponse, error)
+	// DelegatorUnbondingDelegations queries all unbonding delegations of a given
+	// delegator address.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	DelegatorUnbondingDelegations(context.Context, *QueryDelegatorUnbondingDelegationsRequest) (*QueryDelegatorUnbondingDelegationsResponse, error)
+	// Redelegations queries redelegations of given address.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	Redelegations(context.Context, *QueryRedelegationsRequest) (*QueryRedelegationsResponse, error)
+	// DelegatorValidators queries all validators info for given delegator
+	// address.
+	//
+	// When called from another module, this query might consume a high amount of
+	// gas if the pagination field is incorrectly set.
+	DelegatorValidators(context.Context, *QueryDelegatorValidatorsRequest) (*QueryDelegatorValidatorsResponse, error)
+	// DelegatorValidator queries validator info for given delegator validator
+	// pair.
+	DelegatorValidator(context.Context, *QueryDelegatorValidatorRequest) (*QueryDelegatorValidatorResponse, error)
+	// HistoricalInfo queries the historical info for given height.
+	HistoricalInfo(context.Context, *QueryHistoricalInfoRequest) (*QueryHistoricalInfoResponse, error)
+	// Pool queries the pool info.
+	Pool(context.Context, *QueryPoolRequest) (*QueryPoolResponse, error)
+	// Parameters queries the staking parameters.
+	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
+	mustEmbedUnimplementedQueryServer()
+}
+
+// UnimplementedQueryServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedQueryServer struct{}
+
+func (UnimplementedQueryServer) Validators(context.Context, *QueryValidatorsRequest) (*QueryValidatorsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Validators not implemented")
+}
+func (UnimplementedQueryServer) Validator(context.Context, *QueryValidatorRequest) (*QueryValidatorResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Validator not implemented")
+}
+func (UnimplementedQueryServer) ValidatorDelegations(context.Context, *QueryValidatorDelegationsRequest) (*QueryValidatorDelegationsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ValidatorDelegations not implemented")
+}
+func (UnimplementedQueryServer) ValidatorUnbondingDelegations(context.Context, *QueryValidatorUnbondingDelegationsRequest) (*QueryValidatorUnbondingDelegationsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ValidatorUnbondingDelegations not implemented")
+}
+func (UnimplementedQueryServer) Delegation(context.Context, *QueryDelegationRequest) (*QueryDelegationResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Delegation not implemented")
+}
+func (UnimplementedQueryServer) UnbondingDelegation(context.Context, *QueryUnbondingDelegationRequest) (*QueryUnbondingDelegationResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method UnbondingDelegation not implemented")
+}
+func (UnimplementedQueryServer) DelegatorDelegations(context.Context, *QueryDelegatorDelegationsRequest) (*QueryDelegatorDelegationsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DelegatorDelegations not implemented")
+}
+func (UnimplementedQueryServer) DelegatorUnbondingDelegations(context.Context, *QueryDelegatorUnbondingDelegationsRequest) (*QueryDelegatorUnbondingDelegationsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DelegatorUnbondingDelegations not implemented")
+}
+func (UnimplementedQueryServer) Redelegations(context.Context, *QueryRedelegationsRequest) (*QueryRedelegationsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Redelegations not implemented")
+}
+func (UnimplementedQueryServer) DelegatorValidators(context.Context, *QueryDelegatorValidatorsRequest) (*QueryDelegatorValidatorsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DelegatorValidators not implemented")
+}
+func (UnimplementedQueryServer) DelegatorValidator(context.Context, *QueryDelegatorValidatorRequest) (*QueryDelegatorValidatorResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DelegatorValidator not implemented")
+}
+func (UnimplementedQueryServer) HistoricalInfo(context.Context, *QueryHistoricalInfoRequest) (*QueryHistoricalInfoResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method HistoricalInfo not implemented")
+}
+func (UnimplementedQueryServer) Pool(context.Context, *QueryPoolRequest) (*QueryPoolResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Pool not implemented")
+}
+func (UnimplementedQueryServer) Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
+}
+func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {}
+func (UnimplementedQueryServer) testEmbeddedByValue()               {}
+
+// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to QueryServer will
+// result in compilation errors.
+type UnsafeQueryServer interface {
+	mustEmbedUnimplementedQueryServer()
+}
+
+func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) {
+	// If the following call pancis, it indicates UnimplementedQueryServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&Query_ServiceDesc, srv)
+}
+
+func _Query_Validators_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryValidatorsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).Validators(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_Validators_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).Validators(ctx, req.(*QueryValidatorsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_Validator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryValidatorRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).Validator(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_Validator_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).Validator(ctx, req.(*QueryValidatorRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_ValidatorDelegations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryValidatorDelegationsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).ValidatorDelegations(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_ValidatorDelegations_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).ValidatorDelegations(ctx, req.(*QueryValidatorDelegationsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_ValidatorUnbondingDelegations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryValidatorUnbondingDelegationsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).ValidatorUnbondingDelegations(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_ValidatorUnbondingDelegations_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).ValidatorUnbondingDelegations(ctx, req.(*QueryValidatorUnbondingDelegationsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_Delegation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryDelegationRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).Delegation(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_Delegation_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).Delegation(ctx, req.(*QueryDelegationRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_UnbondingDelegation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryUnbondingDelegationRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).UnbondingDelegation(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_UnbondingDelegation_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).UnbondingDelegation(ctx, req.(*QueryUnbondingDelegationRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_DelegatorDelegations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryDelegatorDelegationsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).DelegatorDelegations(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_DelegatorDelegations_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).DelegatorDelegations(ctx, req.(*QueryDelegatorDelegationsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_DelegatorUnbondingDelegations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryDelegatorUnbondingDelegationsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).DelegatorUnbondingDelegations(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_DelegatorUnbondingDelegations_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).DelegatorUnbondingDelegations(ctx, req.(*QueryDelegatorUnbondingDelegationsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_Redelegations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryRedelegationsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).Redelegations(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_Redelegations_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).Redelegations(ctx, req.(*QueryRedelegationsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_DelegatorValidators_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryDelegatorValidatorsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).DelegatorValidators(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_DelegatorValidators_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).DelegatorValidators(ctx, req.(*QueryDelegatorValidatorsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_DelegatorValidator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryDelegatorValidatorRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).DelegatorValidator(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_DelegatorValidator_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).DelegatorValidator(ctx, req.(*QueryDelegatorValidatorRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_HistoricalInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryHistoricalInfoRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).HistoricalInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_HistoricalInfo_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).HistoricalInfo(ctx, req.(*QueryHistoricalInfoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_Pool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryPoolRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).Pool(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_Pool_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).Pool(ctx, req.(*QueryPoolRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryParamsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).Params(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_Params_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Query_ServiceDesc is the grpc.ServiceDesc for Query service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Query_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "cosmos.staking.v1beta1.Query",
+	HandlerType: (*QueryServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Validators",
+			Handler:    _Query_Validators_Handler,
+		},
+		{
+			MethodName: "Validator",
+			Handler:    _Query_Validator_Handler,
+		},
+		{
+			MethodName: "ValidatorDelegations",
+			Handler:    _Query_ValidatorDelegations_Handler,
+		},
+		{
+			MethodName: "ValidatorUnbondingDelegations",
+			Handler:    _Query_ValidatorUnbondingDelegations_Handler,
+		},
+		{
+			MethodName: "Delegation",
+			Handler:    _Query_Delegation_Handler,
+		},
+		{
+			MethodName: "UnbondingDelegation",
+			Handler:    _Query_UnbondingDelegation_Handler,
+		},
+		{
+			MethodName: "DelegatorDelegations",
+			Handler:    _Query_DelegatorDelegations_Handler,
+		},
+		{
+			MethodName: "DelegatorUnbondingDelegations",
+			Handler:    _Query_DelegatorUnbondingDelegations_Handler,
+		},
+		{
+			MethodName: "Redelegations",
+			Handler:    _Query_Redelegations_Handler,
+		},
+		{
+			MethodName: "DelegatorValidators",
+			Handler:    _Query_DelegatorValidators_Handler,
+		},
+		{
+			MethodName: "DelegatorValidator",
+			Handler:    _Query_DelegatorValidator_Handler,
+		},
+		{
+			MethodName: "HistoricalInfo",
+			Handler:    _Query_HistoricalInfo_Handler,
+		},
+		{
+			MethodName: "Pool",
+			Handler:    _Query_Pool_Handler,
+		},
+		{
+			MethodName: "Params",
+			Handler:    _Query_Params_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "cosmos/staking/v1beta1/query.proto",
+}
diff --git a/atomone-api/cosmos/staking/v1beta1/staking.pulsar.go b/atomone-api/cosmos/staking/v1beta1/staking.pulsar.go
new file mode 100644
index 000000000000..9ff18ca17bcb
--- /dev/null
+++ b/atomone-api/cosmos/staking/v1beta1/staking.pulsar.go
@@ -0,0 +1,14863 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package stakingv1beta1
+
+import (
+	_ "cosmossdk.io/api/amino"
+	v1beta1 "cosmossdk.io/api/cosmos/base/v1beta1"
+	abci "cosmossdk.io/api/tendermint/abci"
+	types "cosmossdk.io/api/tendermint/types"
+	fmt "fmt"
+	_ "github.com/cosmos/cosmos-proto"
+	runtime "github.com/cosmos/cosmos-proto/runtime"
+	_ "github.com/cosmos/gogoproto/gogoproto"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	anypb "google.golang.org/protobuf/types/known/anypb"
+	durationpb "google.golang.org/protobuf/types/known/durationpb"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	io "io"
+	reflect "reflect"
+	sync "sync"
+)
+
+var _ protoreflect.List = (*_HistoricalInfo_2_list)(nil)
+
+type _HistoricalInfo_2_list struct {
+	list *[]*Validator
+}
+
+func (x *_HistoricalInfo_2_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_HistoricalInfo_2_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_HistoricalInfo_2_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Validator)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_HistoricalInfo_2_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Validator)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_HistoricalInfo_2_list) AppendMutable() protoreflect.Value {
+	v := new(Validator)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_HistoricalInfo_2_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_HistoricalInfo_2_list) NewElement() protoreflect.Value {
+	v := new(Validator)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_HistoricalInfo_2_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_HistoricalInfo        protoreflect.MessageDescriptor
+	fd_HistoricalInfo_header protoreflect.FieldDescriptor
+	fd_HistoricalInfo_valset protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_HistoricalInfo = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("HistoricalInfo")
+	fd_HistoricalInfo_header = md_HistoricalInfo.Fields().ByName("header")
+	fd_HistoricalInfo_valset = md_HistoricalInfo.Fields().ByName("valset")
+}
+
+var _ protoreflect.Message = (*fastReflection_HistoricalInfo)(nil)
+
+type fastReflection_HistoricalInfo HistoricalInfo
+
+func (x *HistoricalInfo) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_HistoricalInfo)(x)
+}
+
+func (x *HistoricalInfo) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_HistoricalInfo_messageType fastReflection_HistoricalInfo_messageType
+var _ protoreflect.MessageType = fastReflection_HistoricalInfo_messageType{}
+
+type fastReflection_HistoricalInfo_messageType struct{}
+
+func (x fastReflection_HistoricalInfo_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_HistoricalInfo)(nil)
+}
+func (x fastReflection_HistoricalInfo_messageType) New() protoreflect.Message {
+	return new(fastReflection_HistoricalInfo)
+}
+func (x fastReflection_HistoricalInfo_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_HistoricalInfo
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_HistoricalInfo) Descriptor() protoreflect.MessageDescriptor {
+	return md_HistoricalInfo
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_HistoricalInfo) Type() protoreflect.MessageType {
+	return _fastReflection_HistoricalInfo_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_HistoricalInfo) New() protoreflect.Message {
+	return new(fastReflection_HistoricalInfo)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_HistoricalInfo) Interface() protoreflect.ProtoMessage {
+	return (*HistoricalInfo)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_HistoricalInfo) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Header != nil {
+		value := protoreflect.ValueOfMessage(x.Header.ProtoReflect())
+		if !f(fd_HistoricalInfo_header, value) {
+			return
+		}
+	}
+	if len(x.Valset) != 0 {
+		value := protoreflect.ValueOfList(&_HistoricalInfo_2_list{list: &x.Valset})
+		if !f(fd_HistoricalInfo_valset, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_HistoricalInfo) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.HistoricalInfo.header":
+		return x.Header != nil
+	case "cosmos.staking.v1beta1.HistoricalInfo.valset":
+		return len(x.Valset) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.HistoricalInfo"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.HistoricalInfo does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_HistoricalInfo) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.HistoricalInfo.header":
+		x.Header = nil
+	case "cosmos.staking.v1beta1.HistoricalInfo.valset":
+		x.Valset = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.HistoricalInfo"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.HistoricalInfo does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_HistoricalInfo) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.HistoricalInfo.header":
+		value := x.Header
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.HistoricalInfo.valset":
+		if len(x.Valset) == 0 {
+			return protoreflect.ValueOfList(&_HistoricalInfo_2_list{})
+		}
+		listValue := &_HistoricalInfo_2_list{list: &x.Valset}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.HistoricalInfo"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.HistoricalInfo does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_HistoricalInfo) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.HistoricalInfo.header":
+		x.Header = value.Message().Interface().(*types.Header)
+	case "cosmos.staking.v1beta1.HistoricalInfo.valset":
+		lv := value.List()
+		clv := lv.(*_HistoricalInfo_2_list)
+		x.Valset = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.HistoricalInfo"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.HistoricalInfo does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_HistoricalInfo) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.HistoricalInfo.header":
+		if x.Header == nil {
+			x.Header = new(types.Header)
+		}
+		return protoreflect.ValueOfMessage(x.Header.ProtoReflect())
+	case "cosmos.staking.v1beta1.HistoricalInfo.valset":
+		if x.Valset == nil {
+			x.Valset = []*Validator{}
+		}
+		value := &_HistoricalInfo_2_list{list: &x.Valset}
+		return protoreflect.ValueOfList(value)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.HistoricalInfo"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.HistoricalInfo does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_HistoricalInfo) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.HistoricalInfo.header":
+		m := new(types.Header)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.HistoricalInfo.valset":
+		list := []*Validator{}
+		return protoreflect.ValueOfList(&_HistoricalInfo_2_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.HistoricalInfo"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.HistoricalInfo does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_HistoricalInfo) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.HistoricalInfo", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_HistoricalInfo) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_HistoricalInfo) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_HistoricalInfo) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_HistoricalInfo) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*HistoricalInfo)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Header != nil {
+			l = options.Size(x.Header)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.Valset) > 0 {
+			for _, e := range x.Valset {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*HistoricalInfo)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Valset) > 0 {
+			for iNdEx := len(x.Valset) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Valset[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x12
+			}
+		}
+		if x.Header != nil {
+			encoded, err := options.Marshal(x.Header)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*HistoricalInfo)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: HistoricalInfo: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: HistoricalInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Header == nil {
+					x.Header = &types.Header{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Header); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Valset", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Valset = append(x.Valset, &Validator{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Valset[len(x.Valset)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_CommissionRates                 protoreflect.MessageDescriptor
+	fd_CommissionRates_rate            protoreflect.FieldDescriptor
+	fd_CommissionRates_max_rate        protoreflect.FieldDescriptor
+	fd_CommissionRates_max_change_rate protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_CommissionRates = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("CommissionRates")
+	fd_CommissionRates_rate = md_CommissionRates.Fields().ByName("rate")
+	fd_CommissionRates_max_rate = md_CommissionRates.Fields().ByName("max_rate")
+	fd_CommissionRates_max_change_rate = md_CommissionRates.Fields().ByName("max_change_rate")
+}
+
+var _ protoreflect.Message = (*fastReflection_CommissionRates)(nil)
+
+type fastReflection_CommissionRates CommissionRates
+
+func (x *CommissionRates) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_CommissionRates)(x)
+}
+
+func (x *CommissionRates) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_CommissionRates_messageType fastReflection_CommissionRates_messageType
+var _ protoreflect.MessageType = fastReflection_CommissionRates_messageType{}
+
+type fastReflection_CommissionRates_messageType struct{}
+
+func (x fastReflection_CommissionRates_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_CommissionRates)(nil)
+}
+func (x fastReflection_CommissionRates_messageType) New() protoreflect.Message {
+	return new(fastReflection_CommissionRates)
+}
+func (x fastReflection_CommissionRates_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_CommissionRates
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_CommissionRates) Descriptor() protoreflect.MessageDescriptor {
+	return md_CommissionRates
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_CommissionRates) Type() protoreflect.MessageType {
+	return _fastReflection_CommissionRates_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_CommissionRates) New() protoreflect.Message {
+	return new(fastReflection_CommissionRates)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_CommissionRates) Interface() protoreflect.ProtoMessage {
+	return (*CommissionRates)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_CommissionRates) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Rate != "" {
+		value := protoreflect.ValueOfString(x.Rate)
+		if !f(fd_CommissionRates_rate, value) {
+			return
+		}
+	}
+	if x.MaxRate != "" {
+		value := protoreflect.ValueOfString(x.MaxRate)
+		if !f(fd_CommissionRates_max_rate, value) {
+			return
+		}
+	}
+	if x.MaxChangeRate != "" {
+		value := protoreflect.ValueOfString(x.MaxChangeRate)
+		if !f(fd_CommissionRates_max_change_rate, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_CommissionRates) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.CommissionRates.rate":
+		return x.Rate != ""
+	case "cosmos.staking.v1beta1.CommissionRates.max_rate":
+		return x.MaxRate != ""
+	case "cosmos.staking.v1beta1.CommissionRates.max_change_rate":
+		return x.MaxChangeRate != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.CommissionRates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.CommissionRates does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_CommissionRates) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.CommissionRates.rate":
+		x.Rate = ""
+	case "cosmos.staking.v1beta1.CommissionRates.max_rate":
+		x.MaxRate = ""
+	case "cosmos.staking.v1beta1.CommissionRates.max_change_rate":
+		x.MaxChangeRate = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.CommissionRates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.CommissionRates does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_CommissionRates) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.CommissionRates.rate":
+		value := x.Rate
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.CommissionRates.max_rate":
+		value := x.MaxRate
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.CommissionRates.max_change_rate":
+		value := x.MaxChangeRate
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.CommissionRates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.CommissionRates does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_CommissionRates) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.CommissionRates.rate":
+		x.Rate = value.Interface().(string)
+	case "cosmos.staking.v1beta1.CommissionRates.max_rate":
+		x.MaxRate = value.Interface().(string)
+	case "cosmos.staking.v1beta1.CommissionRates.max_change_rate":
+		x.MaxChangeRate = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.CommissionRates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.CommissionRates does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_CommissionRates) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.CommissionRates.rate":
+		panic(fmt.Errorf("field rate of message cosmos.staking.v1beta1.CommissionRates is not mutable"))
+	case "cosmos.staking.v1beta1.CommissionRates.max_rate":
+		panic(fmt.Errorf("field max_rate of message cosmos.staking.v1beta1.CommissionRates is not mutable"))
+	case "cosmos.staking.v1beta1.CommissionRates.max_change_rate":
+		panic(fmt.Errorf("field max_change_rate of message cosmos.staking.v1beta1.CommissionRates is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.CommissionRates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.CommissionRates does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_CommissionRates) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.CommissionRates.rate":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.CommissionRates.max_rate":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.CommissionRates.max_change_rate":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.CommissionRates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.CommissionRates does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_CommissionRates) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.CommissionRates", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_CommissionRates) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_CommissionRates) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_CommissionRates) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_CommissionRates) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*CommissionRates)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Rate)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.MaxRate)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.MaxChangeRate)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*CommissionRates)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.MaxChangeRate) > 0 {
+			i -= len(x.MaxChangeRate)
+			copy(dAtA[i:], x.MaxChangeRate)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MaxChangeRate)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.MaxRate) > 0 {
+			i -= len(x.MaxRate)
+			copy(dAtA[i:], x.MaxRate)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MaxRate)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.Rate) > 0 {
+			i -= len(x.Rate)
+			copy(dAtA[i:], x.Rate)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Rate)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*CommissionRates)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CommissionRates: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CommissionRates: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Rate", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Rate = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaxRate", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.MaxRate = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaxChangeRate", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.MaxChangeRate = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_Commission                  protoreflect.MessageDescriptor
+	fd_Commission_commission_rates protoreflect.FieldDescriptor
+	fd_Commission_update_time      protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_Commission = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("Commission")
+	fd_Commission_commission_rates = md_Commission.Fields().ByName("commission_rates")
+	fd_Commission_update_time = md_Commission.Fields().ByName("update_time")
+}
+
+var _ protoreflect.Message = (*fastReflection_Commission)(nil)
+
+type fastReflection_Commission Commission
+
+func (x *Commission) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_Commission)(x)
+}
+
+func (x *Commission) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_Commission_messageType fastReflection_Commission_messageType
+var _ protoreflect.MessageType = fastReflection_Commission_messageType{}
+
+type fastReflection_Commission_messageType struct{}
+
+func (x fastReflection_Commission_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_Commission)(nil)
+}
+func (x fastReflection_Commission_messageType) New() protoreflect.Message {
+	return new(fastReflection_Commission)
+}
+func (x fastReflection_Commission_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_Commission
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Commission) Descriptor() protoreflect.MessageDescriptor {
+	return md_Commission
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_Commission) Type() protoreflect.MessageType {
+	return _fastReflection_Commission_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Commission) New() protoreflect.Message {
+	return new(fastReflection_Commission)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Commission) Interface() protoreflect.ProtoMessage {
+	return (*Commission)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_Commission) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.CommissionRates != nil {
+		value := protoreflect.ValueOfMessage(x.CommissionRates.ProtoReflect())
+		if !f(fd_Commission_commission_rates, value) {
+			return
+		}
+	}
+	if x.UpdateTime != nil {
+		value := protoreflect.ValueOfMessage(x.UpdateTime.ProtoReflect())
+		if !f(fd_Commission_update_time, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_Commission) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Commission.commission_rates":
+		return x.CommissionRates != nil
+	case "cosmos.staking.v1beta1.Commission.update_time":
+		return x.UpdateTime != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Commission"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Commission does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Commission) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Commission.commission_rates":
+		x.CommissionRates = nil
+	case "cosmos.staking.v1beta1.Commission.update_time":
+		x.UpdateTime = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Commission"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Commission does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_Commission) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.Commission.commission_rates":
+		value := x.CommissionRates
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.Commission.update_time":
+		value := x.UpdateTime
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Commission"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Commission does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Commission) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Commission.commission_rates":
+		x.CommissionRates = value.Message().Interface().(*CommissionRates)
+	case "cosmos.staking.v1beta1.Commission.update_time":
+		x.UpdateTime = value.Message().Interface().(*timestamppb.Timestamp)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Commission"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Commission does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Commission) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Commission.commission_rates":
+		if x.CommissionRates == nil {
+			x.CommissionRates = new(CommissionRates)
+		}
+		return protoreflect.ValueOfMessage(x.CommissionRates.ProtoReflect())
+	case "cosmos.staking.v1beta1.Commission.update_time":
+		if x.UpdateTime == nil {
+			x.UpdateTime = new(timestamppb.Timestamp)
+		}
+		return protoreflect.ValueOfMessage(x.UpdateTime.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Commission"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Commission does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_Commission) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Commission.commission_rates":
+		m := new(CommissionRates)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.Commission.update_time":
+		m := new(timestamppb.Timestamp)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Commission"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Commission does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_Commission) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.Commission", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_Commission) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Commission) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_Commission) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_Commission) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*Commission)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.CommissionRates != nil {
+			l = options.Size(x.CommissionRates)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.UpdateTime != nil {
+			l = options.Size(x.UpdateTime)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*Commission)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.UpdateTime != nil {
+			encoded, err := options.Marshal(x.UpdateTime)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.CommissionRates != nil {
+			encoded, err := options.Marshal(x.CommissionRates)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*Commission)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Commission: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Commission: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CommissionRates", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.CommissionRates == nil {
+					x.CommissionRates = &CommissionRates{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CommissionRates); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.UpdateTime == nil {
+					x.UpdateTime = &timestamppb.Timestamp{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.UpdateTime); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_Description                  protoreflect.MessageDescriptor
+	fd_Description_moniker          protoreflect.FieldDescriptor
+	fd_Description_identity         protoreflect.FieldDescriptor
+	fd_Description_website          protoreflect.FieldDescriptor
+	fd_Description_security_contact protoreflect.FieldDescriptor
+	fd_Description_details          protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_Description = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("Description")
+	fd_Description_moniker = md_Description.Fields().ByName("moniker")
+	fd_Description_identity = md_Description.Fields().ByName("identity")
+	fd_Description_website = md_Description.Fields().ByName("website")
+	fd_Description_security_contact = md_Description.Fields().ByName("security_contact")
+	fd_Description_details = md_Description.Fields().ByName("details")
+}
+
+var _ protoreflect.Message = (*fastReflection_Description)(nil)
+
+type fastReflection_Description Description
+
+func (x *Description) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_Description)(x)
+}
+
+func (x *Description) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_Description_messageType fastReflection_Description_messageType
+var _ protoreflect.MessageType = fastReflection_Description_messageType{}
+
+type fastReflection_Description_messageType struct{}
+
+func (x fastReflection_Description_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_Description)(nil)
+}
+func (x fastReflection_Description_messageType) New() protoreflect.Message {
+	return new(fastReflection_Description)
+}
+func (x fastReflection_Description_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_Description
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Description) Descriptor() protoreflect.MessageDescriptor {
+	return md_Description
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_Description) Type() protoreflect.MessageType {
+	return _fastReflection_Description_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Description) New() protoreflect.Message {
+	return new(fastReflection_Description)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Description) Interface() protoreflect.ProtoMessage {
+	return (*Description)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_Description) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Moniker != "" {
+		value := protoreflect.ValueOfString(x.Moniker)
+		if !f(fd_Description_moniker, value) {
+			return
+		}
+	}
+	if x.Identity != "" {
+		value := protoreflect.ValueOfString(x.Identity)
+		if !f(fd_Description_identity, value) {
+			return
+		}
+	}
+	if x.Website != "" {
+		value := protoreflect.ValueOfString(x.Website)
+		if !f(fd_Description_website, value) {
+			return
+		}
+	}
+	if x.SecurityContact != "" {
+		value := protoreflect.ValueOfString(x.SecurityContact)
+		if !f(fd_Description_security_contact, value) {
+			return
+		}
+	}
+	if x.Details != "" {
+		value := protoreflect.ValueOfString(x.Details)
+		if !f(fd_Description_details, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_Description) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Description.moniker":
+		return x.Moniker != ""
+	case "cosmos.staking.v1beta1.Description.identity":
+		return x.Identity != ""
+	case "cosmos.staking.v1beta1.Description.website":
+		return x.Website != ""
+	case "cosmos.staking.v1beta1.Description.security_contact":
+		return x.SecurityContact != ""
+	case "cosmos.staking.v1beta1.Description.details":
+		return x.Details != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Description"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Description does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Description) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Description.moniker":
+		x.Moniker = ""
+	case "cosmos.staking.v1beta1.Description.identity":
+		x.Identity = ""
+	case "cosmos.staking.v1beta1.Description.website":
+		x.Website = ""
+	case "cosmos.staking.v1beta1.Description.security_contact":
+		x.SecurityContact = ""
+	case "cosmos.staking.v1beta1.Description.details":
+		x.Details = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Description"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Description does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_Description) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.Description.moniker":
+		value := x.Moniker
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Description.identity":
+		value := x.Identity
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Description.website":
+		value := x.Website
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Description.security_contact":
+		value := x.SecurityContact
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Description.details":
+		value := x.Details
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Description"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Description does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Description) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Description.moniker":
+		x.Moniker = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Description.identity":
+		x.Identity = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Description.website":
+		x.Website = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Description.security_contact":
+		x.SecurityContact = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Description.details":
+		x.Details = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Description"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Description does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Description) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Description.moniker":
+		panic(fmt.Errorf("field moniker of message cosmos.staking.v1beta1.Description is not mutable"))
+	case "cosmos.staking.v1beta1.Description.identity":
+		panic(fmt.Errorf("field identity of message cosmos.staking.v1beta1.Description is not mutable"))
+	case "cosmos.staking.v1beta1.Description.website":
+		panic(fmt.Errorf("field website of message cosmos.staking.v1beta1.Description is not mutable"))
+	case "cosmos.staking.v1beta1.Description.security_contact":
+		panic(fmt.Errorf("field security_contact of message cosmos.staking.v1beta1.Description is not mutable"))
+	case "cosmos.staking.v1beta1.Description.details":
+		panic(fmt.Errorf("field details of message cosmos.staking.v1beta1.Description is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Description"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Description does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_Description) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Description.moniker":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Description.identity":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Description.website":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Description.security_contact":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Description.details":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Description"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Description does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_Description) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.Description", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_Description) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Description) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_Description) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_Description) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*Description)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Moniker)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Identity)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Website)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.SecurityContact)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Details)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*Description)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Details) > 0 {
+			i -= len(x.Details)
+			copy(dAtA[i:], x.Details)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Details)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if len(x.SecurityContact) > 0 {
+			i -= len(x.SecurityContact)
+			copy(dAtA[i:], x.SecurityContact)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SecurityContact)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.Website) > 0 {
+			i -= len(x.Website)
+			copy(dAtA[i:], x.Website)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Website)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.Identity) > 0 {
+			i -= len(x.Identity)
+			copy(dAtA[i:], x.Identity)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Identity)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.Moniker) > 0 {
+			i -= len(x.Moniker)
+			copy(dAtA[i:], x.Moniker)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Moniker)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*Description)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Description: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Description: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Moniker", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Moniker = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Identity = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Website", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Website = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SecurityContact", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.SecurityContact = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Details = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_Validator_13_list)(nil)
+
+type _Validator_13_list struct {
+	list *[]uint64
+}
+
+func (x *_Validator_13_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_Validator_13_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfUint64((*x.list)[i])
+}
+
+func (x *_Validator_13_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Uint()
+	concreteValue := valueUnwrapped
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_Validator_13_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Uint()
+	concreteValue := valueUnwrapped
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_Validator_13_list) AppendMutable() protoreflect.Value {
+	panic(fmt.Errorf("AppendMutable can not be called on message Validator at list field UnbondingIds as it is not of Message kind"))
+}
+
+func (x *_Validator_13_list) Truncate(n int) {
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_Validator_13_list) NewElement() protoreflect.Value {
+	v := uint64(0)
+	return protoreflect.ValueOfUint64(v)
+}
+
+func (x *_Validator_13_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_Validator                             protoreflect.MessageDescriptor
+	fd_Validator_operator_address            protoreflect.FieldDescriptor
+	fd_Validator_consensus_pubkey            protoreflect.FieldDescriptor
+	fd_Validator_jailed                      protoreflect.FieldDescriptor
+	fd_Validator_status                      protoreflect.FieldDescriptor
+	fd_Validator_tokens                      protoreflect.FieldDescriptor
+	fd_Validator_delegator_shares            protoreflect.FieldDescriptor
+	fd_Validator_description                 protoreflect.FieldDescriptor
+	fd_Validator_unbonding_height            protoreflect.FieldDescriptor
+	fd_Validator_unbonding_time              protoreflect.FieldDescriptor
+	fd_Validator_commission                  protoreflect.FieldDescriptor
+	fd_Validator_min_self_delegation         protoreflect.FieldDescriptor
+	fd_Validator_unbonding_on_hold_ref_count protoreflect.FieldDescriptor
+	fd_Validator_unbonding_ids               protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_Validator = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("Validator")
+	fd_Validator_operator_address = md_Validator.Fields().ByName("operator_address")
+	fd_Validator_consensus_pubkey = md_Validator.Fields().ByName("consensus_pubkey")
+	fd_Validator_jailed = md_Validator.Fields().ByName("jailed")
+	fd_Validator_status = md_Validator.Fields().ByName("status")
+	fd_Validator_tokens = md_Validator.Fields().ByName("tokens")
+	fd_Validator_delegator_shares = md_Validator.Fields().ByName("delegator_shares")
+	fd_Validator_description = md_Validator.Fields().ByName("description")
+	fd_Validator_unbonding_height = md_Validator.Fields().ByName("unbonding_height")
+	fd_Validator_unbonding_time = md_Validator.Fields().ByName("unbonding_time")
+	fd_Validator_commission = md_Validator.Fields().ByName("commission")
+	fd_Validator_min_self_delegation = md_Validator.Fields().ByName("min_self_delegation")
+	fd_Validator_unbonding_on_hold_ref_count = md_Validator.Fields().ByName("unbonding_on_hold_ref_count")
+	fd_Validator_unbonding_ids = md_Validator.Fields().ByName("unbonding_ids")
+}
+
+var _ protoreflect.Message = (*fastReflection_Validator)(nil)
+
+type fastReflection_Validator Validator
+
+func (x *Validator) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_Validator)(x)
+}
+
+func (x *Validator) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_Validator_messageType fastReflection_Validator_messageType
+var _ protoreflect.MessageType = fastReflection_Validator_messageType{}
+
+type fastReflection_Validator_messageType struct{}
+
+func (x fastReflection_Validator_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_Validator)(nil)
+}
+func (x fastReflection_Validator_messageType) New() protoreflect.Message {
+	return new(fastReflection_Validator)
+}
+func (x fastReflection_Validator_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_Validator
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Validator) Descriptor() protoreflect.MessageDescriptor {
+	return md_Validator
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_Validator) Type() protoreflect.MessageType {
+	return _fastReflection_Validator_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Validator) New() protoreflect.Message {
+	return new(fastReflection_Validator)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Validator) Interface() protoreflect.ProtoMessage {
+	return (*Validator)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_Validator) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.OperatorAddress != "" {
+		value := protoreflect.ValueOfString(x.OperatorAddress)
+		if !f(fd_Validator_operator_address, value) {
+			return
+		}
+	}
+	if x.ConsensusPubkey != nil {
+		value := protoreflect.ValueOfMessage(x.ConsensusPubkey.ProtoReflect())
+		if !f(fd_Validator_consensus_pubkey, value) {
+			return
+		}
+	}
+	if x.Jailed != false {
+		value := protoreflect.ValueOfBool(x.Jailed)
+		if !f(fd_Validator_jailed, value) {
+			return
+		}
+	}
+	if x.Status != 0 {
+		value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+		if !f(fd_Validator_status, value) {
+			return
+		}
+	}
+	if x.Tokens != "" {
+		value := protoreflect.ValueOfString(x.Tokens)
+		if !f(fd_Validator_tokens, value) {
+			return
+		}
+	}
+	if x.DelegatorShares != "" {
+		value := protoreflect.ValueOfString(x.DelegatorShares)
+		if !f(fd_Validator_delegator_shares, value) {
+			return
+		}
+	}
+	if x.Description != nil {
+		value := protoreflect.ValueOfMessage(x.Description.ProtoReflect())
+		if !f(fd_Validator_description, value) {
+			return
+		}
+	}
+	if x.UnbondingHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.UnbondingHeight)
+		if !f(fd_Validator_unbonding_height, value) {
+			return
+		}
+	}
+	if x.UnbondingTime != nil {
+		value := protoreflect.ValueOfMessage(x.UnbondingTime.ProtoReflect())
+		if !f(fd_Validator_unbonding_time, value) {
+			return
+		}
+	}
+	if x.Commission != nil {
+		value := protoreflect.ValueOfMessage(x.Commission.ProtoReflect())
+		if !f(fd_Validator_commission, value) {
+			return
+		}
+	}
+	if x.MinSelfDelegation != "" {
+		value := protoreflect.ValueOfString(x.MinSelfDelegation)
+		if !f(fd_Validator_min_self_delegation, value) {
+			return
+		}
+	}
+	if x.UnbondingOnHoldRefCount != int64(0) {
+		value := protoreflect.ValueOfInt64(x.UnbondingOnHoldRefCount)
+		if !f(fd_Validator_unbonding_on_hold_ref_count, value) {
+			return
+		}
+	}
+	if len(x.UnbondingIds) != 0 {
+		value := protoreflect.ValueOfList(&_Validator_13_list{list: &x.UnbondingIds})
+		if !f(fd_Validator_unbonding_ids, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_Validator) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Validator.operator_address":
+		return x.OperatorAddress != ""
+	case "cosmos.staking.v1beta1.Validator.consensus_pubkey":
+		return x.ConsensusPubkey != nil
+	case "cosmos.staking.v1beta1.Validator.jailed":
+		return x.Jailed != false
+	case "cosmos.staking.v1beta1.Validator.status":
+		return x.Status != 0
+	case "cosmos.staking.v1beta1.Validator.tokens":
+		return x.Tokens != ""
+	case "cosmos.staking.v1beta1.Validator.delegator_shares":
+		return x.DelegatorShares != ""
+	case "cosmos.staking.v1beta1.Validator.description":
+		return x.Description != nil
+	case "cosmos.staking.v1beta1.Validator.unbonding_height":
+		return x.UnbondingHeight != int64(0)
+	case "cosmos.staking.v1beta1.Validator.unbonding_time":
+		return x.UnbondingTime != nil
+	case "cosmos.staking.v1beta1.Validator.commission":
+		return x.Commission != nil
+	case "cosmos.staking.v1beta1.Validator.min_self_delegation":
+		return x.MinSelfDelegation != ""
+	case "cosmos.staking.v1beta1.Validator.unbonding_on_hold_ref_count":
+		return x.UnbondingOnHoldRefCount != int64(0)
+	case "cosmos.staking.v1beta1.Validator.unbonding_ids":
+		return len(x.UnbondingIds) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Validator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Validator does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Validator) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Validator.operator_address":
+		x.OperatorAddress = ""
+	case "cosmos.staking.v1beta1.Validator.consensus_pubkey":
+		x.ConsensusPubkey = nil
+	case "cosmos.staking.v1beta1.Validator.jailed":
+		x.Jailed = false
+	case "cosmos.staking.v1beta1.Validator.status":
+		x.Status = 0
+	case "cosmos.staking.v1beta1.Validator.tokens":
+		x.Tokens = ""
+	case "cosmos.staking.v1beta1.Validator.delegator_shares":
+		x.DelegatorShares = ""
+	case "cosmos.staking.v1beta1.Validator.description":
+		x.Description = nil
+	case "cosmos.staking.v1beta1.Validator.unbonding_height":
+		x.UnbondingHeight = int64(0)
+	case "cosmos.staking.v1beta1.Validator.unbonding_time":
+		x.UnbondingTime = nil
+	case "cosmos.staking.v1beta1.Validator.commission":
+		x.Commission = nil
+	case "cosmos.staking.v1beta1.Validator.min_self_delegation":
+		x.MinSelfDelegation = ""
+	case "cosmos.staking.v1beta1.Validator.unbonding_on_hold_ref_count":
+		x.UnbondingOnHoldRefCount = int64(0)
+	case "cosmos.staking.v1beta1.Validator.unbonding_ids":
+		x.UnbondingIds = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Validator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Validator does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_Validator) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.Validator.operator_address":
+		value := x.OperatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Validator.consensus_pubkey":
+		value := x.ConsensusPubkey
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.jailed":
+		value := x.Jailed
+		return protoreflect.ValueOfBool(value)
+	case "cosmos.staking.v1beta1.Validator.status":
+		value := x.Status
+		return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+	case "cosmos.staking.v1beta1.Validator.tokens":
+		value := x.Tokens
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Validator.delegator_shares":
+		value := x.DelegatorShares
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Validator.description":
+		value := x.Description
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.unbonding_height":
+		value := x.UnbondingHeight
+		return protoreflect.ValueOfInt64(value)
+	case "cosmos.staking.v1beta1.Validator.unbonding_time":
+		value := x.UnbondingTime
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.commission":
+		value := x.Commission
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.min_self_delegation":
+		value := x.MinSelfDelegation
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Validator.unbonding_on_hold_ref_count":
+		value := x.UnbondingOnHoldRefCount
+		return protoreflect.ValueOfInt64(value)
+	case "cosmos.staking.v1beta1.Validator.unbonding_ids":
+		if len(x.UnbondingIds) == 0 {
+			return protoreflect.ValueOfList(&_Validator_13_list{})
+		}
+		listValue := &_Validator_13_list{list: &x.UnbondingIds}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Validator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Validator does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Validator) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Validator.operator_address":
+		x.OperatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Validator.consensus_pubkey":
+		x.ConsensusPubkey = value.Message().Interface().(*anypb.Any)
+	case "cosmos.staking.v1beta1.Validator.jailed":
+		x.Jailed = value.Bool()
+	case "cosmos.staking.v1beta1.Validator.status":
+		x.Status = (BondStatus)(value.Enum())
+	case "cosmos.staking.v1beta1.Validator.tokens":
+		x.Tokens = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Validator.delegator_shares":
+		x.DelegatorShares = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Validator.description":
+		x.Description = value.Message().Interface().(*Description)
+	case "cosmos.staking.v1beta1.Validator.unbonding_height":
+		x.UnbondingHeight = value.Int()
+	case "cosmos.staking.v1beta1.Validator.unbonding_time":
+		x.UnbondingTime = value.Message().Interface().(*timestamppb.Timestamp)
+	case "cosmos.staking.v1beta1.Validator.commission":
+		x.Commission = value.Message().Interface().(*Commission)
+	case "cosmos.staking.v1beta1.Validator.min_self_delegation":
+		x.MinSelfDelegation = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Validator.unbonding_on_hold_ref_count":
+		x.UnbondingOnHoldRefCount = value.Int()
+	case "cosmos.staking.v1beta1.Validator.unbonding_ids":
+		lv := value.List()
+		clv := lv.(*_Validator_13_list)
+		x.UnbondingIds = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Validator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Validator does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Validator) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Validator.consensus_pubkey":
+		if x.ConsensusPubkey == nil {
+			x.ConsensusPubkey = new(anypb.Any)
+		}
+		return protoreflect.ValueOfMessage(x.ConsensusPubkey.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.description":
+		if x.Description == nil {
+			x.Description = new(Description)
+		}
+		return protoreflect.ValueOfMessage(x.Description.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.unbonding_time":
+		if x.UnbondingTime == nil {
+			x.UnbondingTime = new(timestamppb.Timestamp)
+		}
+		return protoreflect.ValueOfMessage(x.UnbondingTime.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.commission":
+		if x.Commission == nil {
+			x.Commission = new(Commission)
+		}
+		return protoreflect.ValueOfMessage(x.Commission.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.unbonding_ids":
+		if x.UnbondingIds == nil {
+			x.UnbondingIds = []uint64{}
+		}
+		value := &_Validator_13_list{list: &x.UnbondingIds}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.Validator.operator_address":
+		panic(fmt.Errorf("field operator_address of message cosmos.staking.v1beta1.Validator is not mutable"))
+	case "cosmos.staking.v1beta1.Validator.jailed":
+		panic(fmt.Errorf("field jailed of message cosmos.staking.v1beta1.Validator is not mutable"))
+	case "cosmos.staking.v1beta1.Validator.status":
+		panic(fmt.Errorf("field status of message cosmos.staking.v1beta1.Validator is not mutable"))
+	case "cosmos.staking.v1beta1.Validator.tokens":
+		panic(fmt.Errorf("field tokens of message cosmos.staking.v1beta1.Validator is not mutable"))
+	case "cosmos.staking.v1beta1.Validator.delegator_shares":
+		panic(fmt.Errorf("field delegator_shares of message cosmos.staking.v1beta1.Validator is not mutable"))
+	case "cosmos.staking.v1beta1.Validator.unbonding_height":
+		panic(fmt.Errorf("field unbonding_height of message cosmos.staking.v1beta1.Validator is not mutable"))
+	case "cosmos.staking.v1beta1.Validator.min_self_delegation":
+		panic(fmt.Errorf("field min_self_delegation of message cosmos.staking.v1beta1.Validator is not mutable"))
+	case "cosmos.staking.v1beta1.Validator.unbonding_on_hold_ref_count":
+		panic(fmt.Errorf("field unbonding_on_hold_ref_count of message cosmos.staking.v1beta1.Validator is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Validator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Validator does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_Validator) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Validator.operator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Validator.consensus_pubkey":
+		m := new(anypb.Any)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.jailed":
+		return protoreflect.ValueOfBool(false)
+	case "cosmos.staking.v1beta1.Validator.status":
+		return protoreflect.ValueOfEnum(0)
+	case "cosmos.staking.v1beta1.Validator.tokens":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Validator.delegator_shares":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Validator.description":
+		m := new(Description)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.unbonding_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "cosmos.staking.v1beta1.Validator.unbonding_time":
+		m := new(timestamppb.Timestamp)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.commission":
+		m := new(Commission)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.Validator.min_self_delegation":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Validator.unbonding_on_hold_ref_count":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "cosmos.staking.v1beta1.Validator.unbonding_ids":
+		list := []uint64{}
+		return protoreflect.ValueOfList(&_Validator_13_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Validator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Validator does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_Validator) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.Validator", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_Validator) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Validator) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_Validator) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_Validator) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*Validator)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.OperatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.ConsensusPubkey != nil {
+			l = options.Size(x.ConsensusPubkey)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Jailed {
+			n += 2
+		}
+		if x.Status != 0 {
+			n += 1 + runtime.Sov(uint64(x.Status))
+		}
+		l = len(x.Tokens)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.DelegatorShares)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Description != nil {
+			l = options.Size(x.Description)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.UnbondingHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.UnbondingHeight))
+		}
+		if x.UnbondingTime != nil {
+			l = options.Size(x.UnbondingTime)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Commission != nil {
+			l = options.Size(x.Commission)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.MinSelfDelegation)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.UnbondingOnHoldRefCount != 0 {
+			n += 1 + runtime.Sov(uint64(x.UnbondingOnHoldRefCount))
+		}
+		if len(x.UnbondingIds) > 0 {
+			l = 0
+			for _, e := range x.UnbondingIds {
+				l += runtime.Sov(uint64(e))
+			}
+			n += 1 + runtime.Sov(uint64(l)) + l
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*Validator)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.UnbondingIds) > 0 {
+			var pksize2 int
+			for _, num := range x.UnbondingIds {
+				pksize2 += runtime.Sov(uint64(num))
+			}
+			i -= pksize2
+			j1 := i
+			for _, num := range x.UnbondingIds {
+				for num >= 1<<7 {
+					dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
+					num >>= 7
+					j1++
+				}
+				dAtA[j1] = uint8(num)
+				j1++
+			}
+			i = runtime.EncodeVarint(dAtA, i, uint64(pksize2))
+			i--
+			dAtA[i] = 0x6a
+		}
+		if x.UnbondingOnHoldRefCount != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.UnbondingOnHoldRefCount))
+			i--
+			dAtA[i] = 0x60
+		}
+		if len(x.MinSelfDelegation) > 0 {
+			i -= len(x.MinSelfDelegation)
+			copy(dAtA[i:], x.MinSelfDelegation)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MinSelfDelegation)))
+			i--
+			dAtA[i] = 0x5a
+		}
+		if x.Commission != nil {
+			encoded, err := options.Marshal(x.Commission)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x52
+		}
+		if x.UnbondingTime != nil {
+			encoded, err := options.Marshal(x.UnbondingTime)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x4a
+		}
+		if x.UnbondingHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.UnbondingHeight))
+			i--
+			dAtA[i] = 0x40
+		}
+		if x.Description != nil {
+			encoded, err := options.Marshal(x.Description)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x3a
+		}
+		if len(x.DelegatorShares) > 0 {
+			i -= len(x.DelegatorShares)
+			copy(dAtA[i:], x.DelegatorShares)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorShares)))
+			i--
+			dAtA[i] = 0x32
+		}
+		if len(x.Tokens) > 0 {
+			i -= len(x.Tokens)
+			copy(dAtA[i:], x.Tokens)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Tokens)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if x.Status != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+			i--
+			dAtA[i] = 0x20
+		}
+		if x.Jailed {
+			i--
+			if x.Jailed {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x18
+		}
+		if x.ConsensusPubkey != nil {
+			encoded, err := options.Marshal(x.ConsensusPubkey)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.OperatorAddress) > 0 {
+			i -= len(x.OperatorAddress)
+			copy(dAtA[i:], x.OperatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OperatorAddress)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*Validator)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Validator: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.OperatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConsensusPubkey", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.ConsensusPubkey == nil {
+					x.ConsensusPubkey = &anypb.Any{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConsensusPubkey); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Jailed", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.Jailed = bool(v != 0)
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+				}
+				x.Status = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Status |= BondStatus(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Tokens", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Tokens = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 6:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorShares", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorShares = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 7:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Description == nil {
+					x.Description = &Description{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Description); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 8:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingHeight", wireType)
+				}
+				x.UnbondingHeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.UnbondingHeight |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 9:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.UnbondingTime == nil {
+					x.UnbondingTime = &timestamppb.Timestamp{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.UnbondingTime); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 10:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Commission", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Commission == nil {
+					x.Commission = &Commission{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Commission); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 11:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MinSelfDelegation", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.MinSelfDelegation = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 12:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingOnHoldRefCount", wireType)
+				}
+				x.UnbondingOnHoldRefCount = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.UnbondingOnHoldRefCount |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 13:
+				if wireType == 0 {
+					var v uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+						}
+						if iNdEx >= l {
+							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						v |= uint64(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					x.UnbondingIds = append(x.UnbondingIds, v)
+				} else if wireType == 2 {
+					var packedLen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+						}
+						if iNdEx >= l {
+							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						packedLen |= int(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					if packedLen < 0 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+					}
+					postIndex := iNdEx + packedLen
+					if postIndex < 0 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+					}
+					if postIndex > l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					var elementCount int
+					var count int
+					for _, integer := range dAtA[iNdEx:postIndex] {
+						if integer < 128 {
+							count++
+						}
+					}
+					elementCount = count
+					if elementCount != 0 && len(x.UnbondingIds) == 0 {
+						x.UnbondingIds = make([]uint64, 0, elementCount)
+					}
+					for iNdEx < postIndex {
+						var v uint64
+						for shift := uint(0); ; shift += 7 {
+							if shift >= 64 {
+								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+							}
+							if iNdEx >= l {
+								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+							}
+							b := dAtA[iNdEx]
+							iNdEx++
+							v |= uint64(b&0x7F) << shift
+							if b < 0x80 {
+								break
+							}
+						}
+						x.UnbondingIds = append(x.UnbondingIds, v)
+					}
+				} else {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingIds", wireType)
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_ValAddresses_1_list)(nil)
+
+type _ValAddresses_1_list struct {
+	list *[]string
+}
+
+func (x *_ValAddresses_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_ValAddresses_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_ValAddresses_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_ValAddresses_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_ValAddresses_1_list) AppendMutable() protoreflect.Value {
+	panic(fmt.Errorf("AppendMutable can not be called on message ValAddresses at list field Addresses as it is not of Message kind"))
+}
+
+func (x *_ValAddresses_1_list) Truncate(n int) {
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_ValAddresses_1_list) NewElement() protoreflect.Value {
+	v := ""
+	return protoreflect.ValueOfString(v)
+}
+
+func (x *_ValAddresses_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_ValAddresses           protoreflect.MessageDescriptor
+	fd_ValAddresses_addresses protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_ValAddresses = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("ValAddresses")
+	fd_ValAddresses_addresses = md_ValAddresses.Fields().ByName("addresses")
+}
+
+var _ protoreflect.Message = (*fastReflection_ValAddresses)(nil)
+
+type fastReflection_ValAddresses ValAddresses
+
+func (x *ValAddresses) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_ValAddresses)(x)
+}
+
+func (x *ValAddresses) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_ValAddresses_messageType fastReflection_ValAddresses_messageType
+var _ protoreflect.MessageType = fastReflection_ValAddresses_messageType{}
+
+type fastReflection_ValAddresses_messageType struct{}
+
+func (x fastReflection_ValAddresses_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_ValAddresses)(nil)
+}
+func (x fastReflection_ValAddresses_messageType) New() protoreflect.Message {
+	return new(fastReflection_ValAddresses)
+}
+func (x fastReflection_ValAddresses_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_ValAddresses
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ValAddresses) Descriptor() protoreflect.MessageDescriptor {
+	return md_ValAddresses
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_ValAddresses) Type() protoreflect.MessageType {
+	return _fastReflection_ValAddresses_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ValAddresses) New() protoreflect.Message {
+	return new(fastReflection_ValAddresses)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ValAddresses) Interface() protoreflect.ProtoMessage {
+	return (*ValAddresses)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_ValAddresses) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Addresses) != 0 {
+		value := protoreflect.ValueOfList(&_ValAddresses_1_list{list: &x.Addresses})
+		if !f(fd_ValAddresses_addresses, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_ValAddresses) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.ValAddresses.addresses":
+		return len(x.Addresses) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValAddresses"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValAddresses does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ValAddresses) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.ValAddresses.addresses":
+		x.Addresses = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValAddresses"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValAddresses does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_ValAddresses) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.ValAddresses.addresses":
+		if len(x.Addresses) == 0 {
+			return protoreflect.ValueOfList(&_ValAddresses_1_list{})
+		}
+		listValue := &_ValAddresses_1_list{list: &x.Addresses}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValAddresses"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValAddresses does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ValAddresses) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.ValAddresses.addresses":
+		lv := value.List()
+		clv := lv.(*_ValAddresses_1_list)
+		x.Addresses = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValAddresses"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValAddresses does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ValAddresses) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.ValAddresses.addresses":
+		if x.Addresses == nil {
+			x.Addresses = []string{}
+		}
+		value := &_ValAddresses_1_list{list: &x.Addresses}
+		return protoreflect.ValueOfList(value)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValAddresses"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValAddresses does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_ValAddresses) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.ValAddresses.addresses":
+		list := []string{}
+		return protoreflect.ValueOfList(&_ValAddresses_1_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValAddresses"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValAddresses does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_ValAddresses) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.ValAddresses", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_ValAddresses) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ValAddresses) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_ValAddresses) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_ValAddresses) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*ValAddresses)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.Addresses) > 0 {
+			for _, s := range x.Addresses {
+				l = len(s)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*ValAddresses)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Addresses) > 0 {
+			for iNdEx := len(x.Addresses) - 1; iNdEx >= 0; iNdEx-- {
+				i -= len(x.Addresses[iNdEx])
+				copy(dAtA[i:], x.Addresses[iNdEx])
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Addresses[iNdEx])))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*ValAddresses)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValAddresses: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValAddresses: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Addresses = append(x.Addresses, string(dAtA[iNdEx:postIndex]))
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_DVPair                   protoreflect.MessageDescriptor
+	fd_DVPair_delegator_address protoreflect.FieldDescriptor
+	fd_DVPair_validator_address protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_DVPair = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("DVPair")
+	fd_DVPair_delegator_address = md_DVPair.Fields().ByName("delegator_address")
+	fd_DVPair_validator_address = md_DVPair.Fields().ByName("validator_address")
+}
+
+var _ protoreflect.Message = (*fastReflection_DVPair)(nil)
+
+type fastReflection_DVPair DVPair
+
+func (x *DVPair) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_DVPair)(x)
+}
+
+func (x *DVPair) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_DVPair_messageType fastReflection_DVPair_messageType
+var _ protoreflect.MessageType = fastReflection_DVPair_messageType{}
+
+type fastReflection_DVPair_messageType struct{}
+
+func (x fastReflection_DVPair_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_DVPair)(nil)
+}
+func (x fastReflection_DVPair_messageType) New() protoreflect.Message {
+	return new(fastReflection_DVPair)
+}
+func (x fastReflection_DVPair_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_DVPair
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_DVPair) Descriptor() protoreflect.MessageDescriptor {
+	return md_DVPair
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_DVPair) Type() protoreflect.MessageType {
+	return _fastReflection_DVPair_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_DVPair) New() protoreflect.Message {
+	return new(fastReflection_DVPair)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_DVPair) Interface() protoreflect.ProtoMessage {
+	return (*DVPair)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_DVPair) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddress != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddress)
+		if !f(fd_DVPair_delegator_address, value) {
+			return
+		}
+	}
+	if x.ValidatorAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddress)
+		if !f(fd_DVPair_validator_address, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_DVPair) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVPair.delegator_address":
+		return x.DelegatorAddress != ""
+	case "cosmos.staking.v1beta1.DVPair.validator_address":
+		return x.ValidatorAddress != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPair"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPair does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVPair) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVPair.delegator_address":
+		x.DelegatorAddress = ""
+	case "cosmos.staking.v1beta1.DVPair.validator_address":
+		x.ValidatorAddress = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPair"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPair does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_DVPair) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.DVPair.delegator_address":
+		value := x.DelegatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.DVPair.validator_address":
+		value := x.ValidatorAddress
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPair"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPair does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVPair) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVPair.delegator_address":
+		x.DelegatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.DVPair.validator_address":
+		x.ValidatorAddress = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPair"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPair does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVPair) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVPair.delegator_address":
+		panic(fmt.Errorf("field delegator_address of message cosmos.staking.v1beta1.DVPair is not mutable"))
+	case "cosmos.staking.v1beta1.DVPair.validator_address":
+		panic(fmt.Errorf("field validator_address of message cosmos.staking.v1beta1.DVPair is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPair"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPair does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_DVPair) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVPair.delegator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.DVPair.validator_address":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPair"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPair does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_DVPair) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.DVPair", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_DVPair) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVPair) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_DVPair) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_DVPair) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*DVPair)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*DVPair)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.ValidatorAddress) > 0 {
+			i -= len(x.ValidatorAddress)
+			copy(dAtA[i:], x.ValidatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddress) > 0 {
+			i -= len(x.DelegatorAddress)
+			copy(dAtA[i:], x.DelegatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddress)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*DVPair)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DVPair: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DVPair: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_DVPairs_1_list)(nil)
+
+type _DVPairs_1_list struct {
+	list *[]*DVPair
+}
+
+func (x *_DVPairs_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_DVPairs_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_DVPairs_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DVPair)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_DVPairs_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DVPair)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_DVPairs_1_list) AppendMutable() protoreflect.Value {
+	v := new(DVPair)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_DVPairs_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_DVPairs_1_list) NewElement() protoreflect.Value {
+	v := new(DVPair)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_DVPairs_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_DVPairs       protoreflect.MessageDescriptor
+	fd_DVPairs_pairs protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_DVPairs = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("DVPairs")
+	fd_DVPairs_pairs = md_DVPairs.Fields().ByName("pairs")
+}
+
+var _ protoreflect.Message = (*fastReflection_DVPairs)(nil)
+
+type fastReflection_DVPairs DVPairs
+
+func (x *DVPairs) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_DVPairs)(x)
+}
+
+func (x *DVPairs) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_DVPairs_messageType fastReflection_DVPairs_messageType
+var _ protoreflect.MessageType = fastReflection_DVPairs_messageType{}
+
+type fastReflection_DVPairs_messageType struct{}
+
+func (x fastReflection_DVPairs_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_DVPairs)(nil)
+}
+func (x fastReflection_DVPairs_messageType) New() protoreflect.Message {
+	return new(fastReflection_DVPairs)
+}
+func (x fastReflection_DVPairs_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_DVPairs
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_DVPairs) Descriptor() protoreflect.MessageDescriptor {
+	return md_DVPairs
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_DVPairs) Type() protoreflect.MessageType {
+	return _fastReflection_DVPairs_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_DVPairs) New() protoreflect.Message {
+	return new(fastReflection_DVPairs)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_DVPairs) Interface() protoreflect.ProtoMessage {
+	return (*DVPairs)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_DVPairs) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Pairs) != 0 {
+		value := protoreflect.ValueOfList(&_DVPairs_1_list{list: &x.Pairs})
+		if !f(fd_DVPairs_pairs, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_DVPairs) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVPairs.pairs":
+		return len(x.Pairs) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPairs"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPairs does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVPairs) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVPairs.pairs":
+		x.Pairs = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPairs"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPairs does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_DVPairs) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.DVPairs.pairs":
+		if len(x.Pairs) == 0 {
+			return protoreflect.ValueOfList(&_DVPairs_1_list{})
+		}
+		listValue := &_DVPairs_1_list{list: &x.Pairs}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPairs"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPairs does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVPairs) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVPairs.pairs":
+		lv := value.List()
+		clv := lv.(*_DVPairs_1_list)
+		x.Pairs = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPairs"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPairs does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVPairs) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVPairs.pairs":
+		if x.Pairs == nil {
+			x.Pairs = []*DVPair{}
+		}
+		value := &_DVPairs_1_list{list: &x.Pairs}
+		return protoreflect.ValueOfList(value)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPairs"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPairs does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_DVPairs) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVPairs.pairs":
+		list := []*DVPair{}
+		return protoreflect.ValueOfList(&_DVPairs_1_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVPairs"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVPairs does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_DVPairs) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.DVPairs", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_DVPairs) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVPairs) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_DVPairs) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_DVPairs) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*DVPairs)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.Pairs) > 0 {
+			for _, e := range x.Pairs {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*DVPairs)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Pairs) > 0 {
+			for iNdEx := len(x.Pairs) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Pairs[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*DVPairs)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DVPairs: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DVPairs: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Pairs = append(x.Pairs, &DVPair{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pairs[len(x.Pairs)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_DVVTriplet                       protoreflect.MessageDescriptor
+	fd_DVVTriplet_delegator_address     protoreflect.FieldDescriptor
+	fd_DVVTriplet_validator_src_address protoreflect.FieldDescriptor
+	fd_DVVTriplet_validator_dst_address protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_DVVTriplet = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("DVVTriplet")
+	fd_DVVTriplet_delegator_address = md_DVVTriplet.Fields().ByName("delegator_address")
+	fd_DVVTriplet_validator_src_address = md_DVVTriplet.Fields().ByName("validator_src_address")
+	fd_DVVTriplet_validator_dst_address = md_DVVTriplet.Fields().ByName("validator_dst_address")
+}
+
+var _ protoreflect.Message = (*fastReflection_DVVTriplet)(nil)
+
+type fastReflection_DVVTriplet DVVTriplet
+
+func (x *DVVTriplet) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_DVVTriplet)(x)
+}
+
+func (x *DVVTriplet) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_DVVTriplet_messageType fastReflection_DVVTriplet_messageType
+var _ protoreflect.MessageType = fastReflection_DVVTriplet_messageType{}
+
+type fastReflection_DVVTriplet_messageType struct{}
+
+func (x fastReflection_DVVTriplet_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_DVVTriplet)(nil)
+}
+func (x fastReflection_DVVTriplet_messageType) New() protoreflect.Message {
+	return new(fastReflection_DVVTriplet)
+}
+func (x fastReflection_DVVTriplet_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_DVVTriplet
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_DVVTriplet) Descriptor() protoreflect.MessageDescriptor {
+	return md_DVVTriplet
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_DVVTriplet) Type() protoreflect.MessageType {
+	return _fastReflection_DVVTriplet_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_DVVTriplet) New() protoreflect.Message {
+	return new(fastReflection_DVVTriplet)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_DVVTriplet) Interface() protoreflect.ProtoMessage {
+	return (*DVVTriplet)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_DVVTriplet) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddress != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddress)
+		if !f(fd_DVVTriplet_delegator_address, value) {
+			return
+		}
+	}
+	if x.ValidatorSrcAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorSrcAddress)
+		if !f(fd_DVVTriplet_validator_src_address, value) {
+			return
+		}
+	}
+	if x.ValidatorDstAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorDstAddress)
+		if !f(fd_DVVTriplet_validator_dst_address, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_DVVTriplet) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplet.delegator_address":
+		return x.DelegatorAddress != ""
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_src_address":
+		return x.ValidatorSrcAddress != ""
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_dst_address":
+		return x.ValidatorDstAddress != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplet"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplet does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVVTriplet) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplet.delegator_address":
+		x.DelegatorAddress = ""
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_src_address":
+		x.ValidatorSrcAddress = ""
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_dst_address":
+		x.ValidatorDstAddress = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplet"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplet does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_DVVTriplet) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplet.delegator_address":
+		value := x.DelegatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_src_address":
+		value := x.ValidatorSrcAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_dst_address":
+		value := x.ValidatorDstAddress
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplet"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplet does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVVTriplet) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplet.delegator_address":
+		x.DelegatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_src_address":
+		x.ValidatorSrcAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_dst_address":
+		x.ValidatorDstAddress = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplet"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplet does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVVTriplet) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplet.delegator_address":
+		panic(fmt.Errorf("field delegator_address of message cosmos.staking.v1beta1.DVVTriplet is not mutable"))
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_src_address":
+		panic(fmt.Errorf("field validator_src_address of message cosmos.staking.v1beta1.DVVTriplet is not mutable"))
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_dst_address":
+		panic(fmt.Errorf("field validator_dst_address of message cosmos.staking.v1beta1.DVVTriplet is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplet"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplet does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_DVVTriplet) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplet.delegator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_src_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.DVVTriplet.validator_dst_address":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplet"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplet does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_DVVTriplet) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.DVVTriplet", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_DVVTriplet) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVVTriplet) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_DVVTriplet) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_DVVTriplet) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*DVVTriplet)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorSrcAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorDstAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*DVVTriplet)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.ValidatorDstAddress) > 0 {
+			i -= len(x.ValidatorDstAddress)
+			copy(dAtA[i:], x.ValidatorDstAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorDstAddress)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.ValidatorSrcAddress) > 0 {
+			i -= len(x.ValidatorSrcAddress)
+			copy(dAtA[i:], x.ValidatorSrcAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorSrcAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddress) > 0 {
+			i -= len(x.DelegatorAddress)
+			copy(dAtA[i:], x.DelegatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddress)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*DVVTriplet)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DVVTriplet: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DVVTriplet: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorSrcAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorSrcAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorDstAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorDstAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_DVVTriplets_1_list)(nil)
+
+type _DVVTriplets_1_list struct {
+	list *[]*DVVTriplet
+}
+
+func (x *_DVVTriplets_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_DVVTriplets_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_DVVTriplets_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DVVTriplet)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_DVVTriplets_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DVVTriplet)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_DVVTriplets_1_list) AppendMutable() protoreflect.Value {
+	v := new(DVVTriplet)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_DVVTriplets_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_DVVTriplets_1_list) NewElement() protoreflect.Value {
+	v := new(DVVTriplet)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_DVVTriplets_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_DVVTriplets          protoreflect.MessageDescriptor
+	fd_DVVTriplets_triplets protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_DVVTriplets = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("DVVTriplets")
+	fd_DVVTriplets_triplets = md_DVVTriplets.Fields().ByName("triplets")
+}
+
+var _ protoreflect.Message = (*fastReflection_DVVTriplets)(nil)
+
+type fastReflection_DVVTriplets DVVTriplets
+
+func (x *DVVTriplets) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_DVVTriplets)(x)
+}
+
+func (x *DVVTriplets) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_DVVTriplets_messageType fastReflection_DVVTriplets_messageType
+var _ protoreflect.MessageType = fastReflection_DVVTriplets_messageType{}
+
+type fastReflection_DVVTriplets_messageType struct{}
+
+func (x fastReflection_DVVTriplets_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_DVVTriplets)(nil)
+}
+func (x fastReflection_DVVTriplets_messageType) New() protoreflect.Message {
+	return new(fastReflection_DVVTriplets)
+}
+func (x fastReflection_DVVTriplets_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_DVVTriplets
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_DVVTriplets) Descriptor() protoreflect.MessageDescriptor {
+	return md_DVVTriplets
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_DVVTriplets) Type() protoreflect.MessageType {
+	return _fastReflection_DVVTriplets_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_DVVTriplets) New() protoreflect.Message {
+	return new(fastReflection_DVVTriplets)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_DVVTriplets) Interface() protoreflect.ProtoMessage {
+	return (*DVVTriplets)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_DVVTriplets) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Triplets) != 0 {
+		value := protoreflect.ValueOfList(&_DVVTriplets_1_list{list: &x.Triplets})
+		if !f(fd_DVVTriplets_triplets, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_DVVTriplets) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplets.triplets":
+		return len(x.Triplets) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplets"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplets does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVVTriplets) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplets.triplets":
+		x.Triplets = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplets"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplets does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_DVVTriplets) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplets.triplets":
+		if len(x.Triplets) == 0 {
+			return protoreflect.ValueOfList(&_DVVTriplets_1_list{})
+		}
+		listValue := &_DVVTriplets_1_list{list: &x.Triplets}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplets"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplets does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVVTriplets) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplets.triplets":
+		lv := value.List()
+		clv := lv.(*_DVVTriplets_1_list)
+		x.Triplets = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplets"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplets does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVVTriplets) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplets.triplets":
+		if x.Triplets == nil {
+			x.Triplets = []*DVVTriplet{}
+		}
+		value := &_DVVTriplets_1_list{list: &x.Triplets}
+		return protoreflect.ValueOfList(value)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplets"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplets does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_DVVTriplets) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DVVTriplets.triplets":
+		list := []*DVVTriplet{}
+		return protoreflect.ValueOfList(&_DVVTriplets_1_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DVVTriplets"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DVVTriplets does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_DVVTriplets) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.DVVTriplets", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_DVVTriplets) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DVVTriplets) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_DVVTriplets) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_DVVTriplets) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*DVVTriplets)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.Triplets) > 0 {
+			for _, e := range x.Triplets {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*DVVTriplets)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Triplets) > 0 {
+			for iNdEx := len(x.Triplets) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Triplets[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*DVVTriplets)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DVVTriplets: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DVVTriplets: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Triplets", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Triplets = append(x.Triplets, &DVVTriplet{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Triplets[len(x.Triplets)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_Delegation                   protoreflect.MessageDescriptor
+	fd_Delegation_delegator_address protoreflect.FieldDescriptor
+	fd_Delegation_validator_address protoreflect.FieldDescriptor
+	fd_Delegation_shares            protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_Delegation = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("Delegation")
+	fd_Delegation_delegator_address = md_Delegation.Fields().ByName("delegator_address")
+	fd_Delegation_validator_address = md_Delegation.Fields().ByName("validator_address")
+	fd_Delegation_shares = md_Delegation.Fields().ByName("shares")
+}
+
+var _ protoreflect.Message = (*fastReflection_Delegation)(nil)
+
+type fastReflection_Delegation Delegation
+
+func (x *Delegation) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_Delegation)(x)
+}
+
+func (x *Delegation) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_Delegation_messageType fastReflection_Delegation_messageType
+var _ protoreflect.MessageType = fastReflection_Delegation_messageType{}
+
+type fastReflection_Delegation_messageType struct{}
+
+func (x fastReflection_Delegation_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_Delegation)(nil)
+}
+func (x fastReflection_Delegation_messageType) New() protoreflect.Message {
+	return new(fastReflection_Delegation)
+}
+func (x fastReflection_Delegation_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_Delegation
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Delegation) Descriptor() protoreflect.MessageDescriptor {
+	return md_Delegation
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_Delegation) Type() protoreflect.MessageType {
+	return _fastReflection_Delegation_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Delegation) New() protoreflect.Message {
+	return new(fastReflection_Delegation)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Delegation) Interface() protoreflect.ProtoMessage {
+	return (*Delegation)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_Delegation) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddress != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddress)
+		if !f(fd_Delegation_delegator_address, value) {
+			return
+		}
+	}
+	if x.ValidatorAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddress)
+		if !f(fd_Delegation_validator_address, value) {
+			return
+		}
+	}
+	if x.Shares != "" {
+		value := protoreflect.ValueOfString(x.Shares)
+		if !f(fd_Delegation_shares, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_Delegation) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Delegation.delegator_address":
+		return x.DelegatorAddress != ""
+	case "cosmos.staking.v1beta1.Delegation.validator_address":
+		return x.ValidatorAddress != ""
+	case "cosmos.staking.v1beta1.Delegation.shares":
+		return x.Shares != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Delegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Delegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Delegation) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Delegation.delegator_address":
+		x.DelegatorAddress = ""
+	case "cosmos.staking.v1beta1.Delegation.validator_address":
+		x.ValidatorAddress = ""
+	case "cosmos.staking.v1beta1.Delegation.shares":
+		x.Shares = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Delegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Delegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_Delegation) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.Delegation.delegator_address":
+		value := x.DelegatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Delegation.validator_address":
+		value := x.ValidatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Delegation.shares":
+		value := x.Shares
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Delegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Delegation does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Delegation) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Delegation.delegator_address":
+		x.DelegatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Delegation.validator_address":
+		x.ValidatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Delegation.shares":
+		x.Shares = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Delegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Delegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Delegation) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Delegation.delegator_address":
+		panic(fmt.Errorf("field delegator_address of message cosmos.staking.v1beta1.Delegation is not mutable"))
+	case "cosmos.staking.v1beta1.Delegation.validator_address":
+		panic(fmt.Errorf("field validator_address of message cosmos.staking.v1beta1.Delegation is not mutable"))
+	case "cosmos.staking.v1beta1.Delegation.shares":
+		panic(fmt.Errorf("field shares of message cosmos.staking.v1beta1.Delegation is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Delegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Delegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_Delegation) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Delegation.delegator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Delegation.validator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Delegation.shares":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Delegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Delegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_Delegation) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.Delegation", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_Delegation) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Delegation) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_Delegation) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_Delegation) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*Delegation)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Shares)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*Delegation)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Shares) > 0 {
+			i -= len(x.Shares)
+			copy(dAtA[i:], x.Shares)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Shares)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.ValidatorAddress) > 0 {
+			i -= len(x.ValidatorAddress)
+			copy(dAtA[i:], x.ValidatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddress) > 0 {
+			i -= len(x.DelegatorAddress)
+			copy(dAtA[i:], x.DelegatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddress)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*Delegation)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Delegation: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Delegation: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Shares", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Shares = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_UnbondingDelegation_3_list)(nil)
+
+type _UnbondingDelegation_3_list struct {
+	list *[]*UnbondingDelegationEntry
+}
+
+func (x *_UnbondingDelegation_3_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_UnbondingDelegation_3_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_UnbondingDelegation_3_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*UnbondingDelegationEntry)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_UnbondingDelegation_3_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*UnbondingDelegationEntry)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_UnbondingDelegation_3_list) AppendMutable() protoreflect.Value {
+	v := new(UnbondingDelegationEntry)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_UnbondingDelegation_3_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_UnbondingDelegation_3_list) NewElement() protoreflect.Value {
+	v := new(UnbondingDelegationEntry)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_UnbondingDelegation_3_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_UnbondingDelegation                   protoreflect.MessageDescriptor
+	fd_UnbondingDelegation_delegator_address protoreflect.FieldDescriptor
+	fd_UnbondingDelegation_validator_address protoreflect.FieldDescriptor
+	fd_UnbondingDelegation_entries           protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_UnbondingDelegation = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("UnbondingDelegation")
+	fd_UnbondingDelegation_delegator_address = md_UnbondingDelegation.Fields().ByName("delegator_address")
+	fd_UnbondingDelegation_validator_address = md_UnbondingDelegation.Fields().ByName("validator_address")
+	fd_UnbondingDelegation_entries = md_UnbondingDelegation.Fields().ByName("entries")
+}
+
+var _ protoreflect.Message = (*fastReflection_UnbondingDelegation)(nil)
+
+type fastReflection_UnbondingDelegation UnbondingDelegation
+
+func (x *UnbondingDelegation) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_UnbondingDelegation)(x)
+}
+
+func (x *UnbondingDelegation) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_UnbondingDelegation_messageType fastReflection_UnbondingDelegation_messageType
+var _ protoreflect.MessageType = fastReflection_UnbondingDelegation_messageType{}
+
+type fastReflection_UnbondingDelegation_messageType struct{}
+
+func (x fastReflection_UnbondingDelegation_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_UnbondingDelegation)(nil)
+}
+func (x fastReflection_UnbondingDelegation_messageType) New() protoreflect.Message {
+	return new(fastReflection_UnbondingDelegation)
+}
+func (x fastReflection_UnbondingDelegation_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_UnbondingDelegation
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_UnbondingDelegation) Descriptor() protoreflect.MessageDescriptor {
+	return md_UnbondingDelegation
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_UnbondingDelegation) Type() protoreflect.MessageType {
+	return _fastReflection_UnbondingDelegation_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_UnbondingDelegation) New() protoreflect.Message {
+	return new(fastReflection_UnbondingDelegation)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_UnbondingDelegation) Interface() protoreflect.ProtoMessage {
+	return (*UnbondingDelegation)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_UnbondingDelegation) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddress != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddress)
+		if !f(fd_UnbondingDelegation_delegator_address, value) {
+			return
+		}
+	}
+	if x.ValidatorAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddress)
+		if !f(fd_UnbondingDelegation_validator_address, value) {
+			return
+		}
+	}
+	if len(x.Entries) != 0 {
+		value := protoreflect.ValueOfList(&_UnbondingDelegation_3_list{list: &x.Entries})
+		if !f(fd_UnbondingDelegation_entries, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_UnbondingDelegation) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegation.delegator_address":
+		return x.DelegatorAddress != ""
+	case "cosmos.staking.v1beta1.UnbondingDelegation.validator_address":
+		return x.ValidatorAddress != ""
+	case "cosmos.staking.v1beta1.UnbondingDelegation.entries":
+		return len(x.Entries) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_UnbondingDelegation) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegation.delegator_address":
+		x.DelegatorAddress = ""
+	case "cosmos.staking.v1beta1.UnbondingDelegation.validator_address":
+		x.ValidatorAddress = ""
+	case "cosmos.staking.v1beta1.UnbondingDelegation.entries":
+		x.Entries = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_UnbondingDelegation) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegation.delegator_address":
+		value := x.DelegatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.UnbondingDelegation.validator_address":
+		value := x.ValidatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.UnbondingDelegation.entries":
+		if len(x.Entries) == 0 {
+			return protoreflect.ValueOfList(&_UnbondingDelegation_3_list{})
+		}
+		listValue := &_UnbondingDelegation_3_list{list: &x.Entries}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegation does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_UnbondingDelegation) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegation.delegator_address":
+		x.DelegatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.UnbondingDelegation.validator_address":
+		x.ValidatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.UnbondingDelegation.entries":
+		lv := value.List()
+		clv := lv.(*_UnbondingDelegation_3_list)
+		x.Entries = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_UnbondingDelegation) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegation.entries":
+		if x.Entries == nil {
+			x.Entries = []*UnbondingDelegationEntry{}
+		}
+		value := &_UnbondingDelegation_3_list{list: &x.Entries}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.UnbondingDelegation.delegator_address":
+		panic(fmt.Errorf("field delegator_address of message cosmos.staking.v1beta1.UnbondingDelegation is not mutable"))
+	case "cosmos.staking.v1beta1.UnbondingDelegation.validator_address":
+		panic(fmt.Errorf("field validator_address of message cosmos.staking.v1beta1.UnbondingDelegation is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_UnbondingDelegation) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegation.delegator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.UnbondingDelegation.validator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.UnbondingDelegation.entries":
+		list := []*UnbondingDelegationEntry{}
+		return protoreflect.ValueOfList(&_UnbondingDelegation_3_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_UnbondingDelegation) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.UnbondingDelegation", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_UnbondingDelegation) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_UnbondingDelegation) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_UnbondingDelegation) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_UnbondingDelegation) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*UnbondingDelegation)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.Entries) > 0 {
+			for _, e := range x.Entries {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*UnbondingDelegation)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Entries) > 0 {
+			for iNdEx := len(x.Entries) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Entries[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x1a
+			}
+		}
+		if len(x.ValidatorAddress) > 0 {
+			i -= len(x.ValidatorAddress)
+			copy(dAtA[i:], x.ValidatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddress) > 0 {
+			i -= len(x.DelegatorAddress)
+			copy(dAtA[i:], x.DelegatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddress)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*UnbondingDelegation)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: UnbondingDelegation: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: UnbondingDelegation: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Entries = append(x.Entries, &UnbondingDelegationEntry{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Entries[len(x.Entries)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_UnbondingDelegationEntry                             protoreflect.MessageDescriptor
+	fd_UnbondingDelegationEntry_creation_height             protoreflect.FieldDescriptor
+	fd_UnbondingDelegationEntry_completion_time             protoreflect.FieldDescriptor
+	fd_UnbondingDelegationEntry_initial_balance             protoreflect.FieldDescriptor
+	fd_UnbondingDelegationEntry_balance                     protoreflect.FieldDescriptor
+	fd_UnbondingDelegationEntry_unbonding_id                protoreflect.FieldDescriptor
+	fd_UnbondingDelegationEntry_unbonding_on_hold_ref_count protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_UnbondingDelegationEntry = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("UnbondingDelegationEntry")
+	fd_UnbondingDelegationEntry_creation_height = md_UnbondingDelegationEntry.Fields().ByName("creation_height")
+	fd_UnbondingDelegationEntry_completion_time = md_UnbondingDelegationEntry.Fields().ByName("completion_time")
+	fd_UnbondingDelegationEntry_initial_balance = md_UnbondingDelegationEntry.Fields().ByName("initial_balance")
+	fd_UnbondingDelegationEntry_balance = md_UnbondingDelegationEntry.Fields().ByName("balance")
+	fd_UnbondingDelegationEntry_unbonding_id = md_UnbondingDelegationEntry.Fields().ByName("unbonding_id")
+	fd_UnbondingDelegationEntry_unbonding_on_hold_ref_count = md_UnbondingDelegationEntry.Fields().ByName("unbonding_on_hold_ref_count")
+}
+
+var _ protoreflect.Message = (*fastReflection_UnbondingDelegationEntry)(nil)
+
+type fastReflection_UnbondingDelegationEntry UnbondingDelegationEntry
+
+func (x *UnbondingDelegationEntry) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_UnbondingDelegationEntry)(x)
+}
+
+func (x *UnbondingDelegationEntry) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_UnbondingDelegationEntry_messageType fastReflection_UnbondingDelegationEntry_messageType
+var _ protoreflect.MessageType = fastReflection_UnbondingDelegationEntry_messageType{}
+
+type fastReflection_UnbondingDelegationEntry_messageType struct{}
+
+func (x fastReflection_UnbondingDelegationEntry_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_UnbondingDelegationEntry)(nil)
+}
+func (x fastReflection_UnbondingDelegationEntry_messageType) New() protoreflect.Message {
+	return new(fastReflection_UnbondingDelegationEntry)
+}
+func (x fastReflection_UnbondingDelegationEntry_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_UnbondingDelegationEntry
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_UnbondingDelegationEntry) Descriptor() protoreflect.MessageDescriptor {
+	return md_UnbondingDelegationEntry
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_UnbondingDelegationEntry) Type() protoreflect.MessageType {
+	return _fastReflection_UnbondingDelegationEntry_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_UnbondingDelegationEntry) New() protoreflect.Message {
+	return new(fastReflection_UnbondingDelegationEntry)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_UnbondingDelegationEntry) Interface() protoreflect.ProtoMessage {
+	return (*UnbondingDelegationEntry)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_UnbondingDelegationEntry) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.CreationHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.CreationHeight)
+		if !f(fd_UnbondingDelegationEntry_creation_height, value) {
+			return
+		}
+	}
+	if x.CompletionTime != nil {
+		value := protoreflect.ValueOfMessage(x.CompletionTime.ProtoReflect())
+		if !f(fd_UnbondingDelegationEntry_completion_time, value) {
+			return
+		}
+	}
+	if x.InitialBalance != "" {
+		value := protoreflect.ValueOfString(x.InitialBalance)
+		if !f(fd_UnbondingDelegationEntry_initial_balance, value) {
+			return
+		}
+	}
+	if x.Balance != "" {
+		value := protoreflect.ValueOfString(x.Balance)
+		if !f(fd_UnbondingDelegationEntry_balance, value) {
+			return
+		}
+	}
+	if x.UnbondingId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.UnbondingId)
+		if !f(fd_UnbondingDelegationEntry_unbonding_id, value) {
+			return
+		}
+	}
+	if x.UnbondingOnHoldRefCount != int64(0) {
+		value := protoreflect.ValueOfInt64(x.UnbondingOnHoldRefCount)
+		if !f(fd_UnbondingDelegationEntry_unbonding_on_hold_ref_count, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_UnbondingDelegationEntry) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.creation_height":
+		return x.CreationHeight != int64(0)
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.completion_time":
+		return x.CompletionTime != nil
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.initial_balance":
+		return x.InitialBalance != ""
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.balance":
+		return x.Balance != ""
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_id":
+		return x.UnbondingId != uint64(0)
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_on_hold_ref_count":
+		return x.UnbondingOnHoldRefCount != int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegationEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_UnbondingDelegationEntry) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.creation_height":
+		x.CreationHeight = int64(0)
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.completion_time":
+		x.CompletionTime = nil
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.initial_balance":
+		x.InitialBalance = ""
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.balance":
+		x.Balance = ""
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_id":
+		x.UnbondingId = uint64(0)
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_on_hold_ref_count":
+		x.UnbondingOnHoldRefCount = int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegationEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_UnbondingDelegationEntry) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.creation_height":
+		value := x.CreationHeight
+		return protoreflect.ValueOfInt64(value)
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.completion_time":
+		value := x.CompletionTime
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.initial_balance":
+		value := x.InitialBalance
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.balance":
+		value := x.Balance
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_id":
+		value := x.UnbondingId
+		return protoreflect.ValueOfUint64(value)
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_on_hold_ref_count":
+		value := x.UnbondingOnHoldRefCount
+		return protoreflect.ValueOfInt64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegationEntry does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_UnbondingDelegationEntry) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.creation_height":
+		x.CreationHeight = value.Int()
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.completion_time":
+		x.CompletionTime = value.Message().Interface().(*timestamppb.Timestamp)
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.initial_balance":
+		x.InitialBalance = value.Interface().(string)
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.balance":
+		x.Balance = value.Interface().(string)
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_id":
+		x.UnbondingId = value.Uint()
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_on_hold_ref_count":
+		x.UnbondingOnHoldRefCount = value.Int()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegationEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_UnbondingDelegationEntry) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.completion_time":
+		if x.CompletionTime == nil {
+			x.CompletionTime = new(timestamppb.Timestamp)
+		}
+		return protoreflect.ValueOfMessage(x.CompletionTime.ProtoReflect())
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.creation_height":
+		panic(fmt.Errorf("field creation_height of message cosmos.staking.v1beta1.UnbondingDelegationEntry is not mutable"))
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.initial_balance":
+		panic(fmt.Errorf("field initial_balance of message cosmos.staking.v1beta1.UnbondingDelegationEntry is not mutable"))
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.balance":
+		panic(fmt.Errorf("field balance of message cosmos.staking.v1beta1.UnbondingDelegationEntry is not mutable"))
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_id":
+		panic(fmt.Errorf("field unbonding_id of message cosmos.staking.v1beta1.UnbondingDelegationEntry is not mutable"))
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_on_hold_ref_count":
+		panic(fmt.Errorf("field unbonding_on_hold_ref_count of message cosmos.staking.v1beta1.UnbondingDelegationEntry is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegationEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_UnbondingDelegationEntry) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.creation_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.completion_time":
+		m := new(timestamppb.Timestamp)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.initial_balance":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.balance":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_id":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "cosmos.staking.v1beta1.UnbondingDelegationEntry.unbonding_on_hold_ref_count":
+		return protoreflect.ValueOfInt64(int64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.UnbondingDelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.UnbondingDelegationEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_UnbondingDelegationEntry) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.UnbondingDelegationEntry", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_UnbondingDelegationEntry) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_UnbondingDelegationEntry) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_UnbondingDelegationEntry) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_UnbondingDelegationEntry) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*UnbondingDelegationEntry)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.CreationHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.CreationHeight))
+		}
+		if x.CompletionTime != nil {
+			l = options.Size(x.CompletionTime)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.InitialBalance)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Balance)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.UnbondingId != 0 {
+			n += 1 + runtime.Sov(uint64(x.UnbondingId))
+		}
+		if x.UnbondingOnHoldRefCount != 0 {
+			n += 1 + runtime.Sov(uint64(x.UnbondingOnHoldRefCount))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*UnbondingDelegationEntry)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.UnbondingOnHoldRefCount != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.UnbondingOnHoldRefCount))
+			i--
+			dAtA[i] = 0x30
+		}
+		if x.UnbondingId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.UnbondingId))
+			i--
+			dAtA[i] = 0x28
+		}
+		if len(x.Balance) > 0 {
+			i -= len(x.Balance)
+			copy(dAtA[i:], x.Balance)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Balance)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.InitialBalance) > 0 {
+			i -= len(x.InitialBalance)
+			copy(dAtA[i:], x.InitialBalance)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InitialBalance)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.CompletionTime != nil {
+			encoded, err := options.Marshal(x.CompletionTime)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.CreationHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.CreationHeight))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*UnbondingDelegationEntry)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: UnbondingDelegationEntry: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: UnbondingDelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType)
+				}
+				x.CreationHeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.CreationHeight |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.CompletionTime == nil {
+					x.CompletionTime = &timestamppb.Timestamp{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CompletionTime); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.InitialBalance = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Balance = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 5:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingId", wireType)
+				}
+				x.UnbondingId = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.UnbondingId |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 6:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingOnHoldRefCount", wireType)
+				}
+				x.UnbondingOnHoldRefCount = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.UnbondingOnHoldRefCount |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_RedelegationEntry                             protoreflect.MessageDescriptor
+	fd_RedelegationEntry_creation_height             protoreflect.FieldDescriptor
+	fd_RedelegationEntry_completion_time             protoreflect.FieldDescriptor
+	fd_RedelegationEntry_initial_balance             protoreflect.FieldDescriptor
+	fd_RedelegationEntry_shares_dst                  protoreflect.FieldDescriptor
+	fd_RedelegationEntry_unbonding_id                protoreflect.FieldDescriptor
+	fd_RedelegationEntry_unbonding_on_hold_ref_count protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_RedelegationEntry = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("RedelegationEntry")
+	fd_RedelegationEntry_creation_height = md_RedelegationEntry.Fields().ByName("creation_height")
+	fd_RedelegationEntry_completion_time = md_RedelegationEntry.Fields().ByName("completion_time")
+	fd_RedelegationEntry_initial_balance = md_RedelegationEntry.Fields().ByName("initial_balance")
+	fd_RedelegationEntry_shares_dst = md_RedelegationEntry.Fields().ByName("shares_dst")
+	fd_RedelegationEntry_unbonding_id = md_RedelegationEntry.Fields().ByName("unbonding_id")
+	fd_RedelegationEntry_unbonding_on_hold_ref_count = md_RedelegationEntry.Fields().ByName("unbonding_on_hold_ref_count")
+}
+
+var _ protoreflect.Message = (*fastReflection_RedelegationEntry)(nil)
+
+type fastReflection_RedelegationEntry RedelegationEntry
+
+func (x *RedelegationEntry) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_RedelegationEntry)(x)
+}
+
+func (x *RedelegationEntry) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_RedelegationEntry_messageType fastReflection_RedelegationEntry_messageType
+var _ protoreflect.MessageType = fastReflection_RedelegationEntry_messageType{}
+
+type fastReflection_RedelegationEntry_messageType struct{}
+
+func (x fastReflection_RedelegationEntry_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_RedelegationEntry)(nil)
+}
+func (x fastReflection_RedelegationEntry_messageType) New() protoreflect.Message {
+	return new(fastReflection_RedelegationEntry)
+}
+func (x fastReflection_RedelegationEntry_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_RedelegationEntry
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_RedelegationEntry) Descriptor() protoreflect.MessageDescriptor {
+	return md_RedelegationEntry
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_RedelegationEntry) Type() protoreflect.MessageType {
+	return _fastReflection_RedelegationEntry_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_RedelegationEntry) New() protoreflect.Message {
+	return new(fastReflection_RedelegationEntry)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_RedelegationEntry) Interface() protoreflect.ProtoMessage {
+	return (*RedelegationEntry)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_RedelegationEntry) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.CreationHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.CreationHeight)
+		if !f(fd_RedelegationEntry_creation_height, value) {
+			return
+		}
+	}
+	if x.CompletionTime != nil {
+		value := protoreflect.ValueOfMessage(x.CompletionTime.ProtoReflect())
+		if !f(fd_RedelegationEntry_completion_time, value) {
+			return
+		}
+	}
+	if x.InitialBalance != "" {
+		value := protoreflect.ValueOfString(x.InitialBalance)
+		if !f(fd_RedelegationEntry_initial_balance, value) {
+			return
+		}
+	}
+	if x.SharesDst != "" {
+		value := protoreflect.ValueOfString(x.SharesDst)
+		if !f(fd_RedelegationEntry_shares_dst, value) {
+			return
+		}
+	}
+	if x.UnbondingId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.UnbondingId)
+		if !f(fd_RedelegationEntry_unbonding_id, value) {
+			return
+		}
+	}
+	if x.UnbondingOnHoldRefCount != int64(0) {
+		value := protoreflect.ValueOfInt64(x.UnbondingOnHoldRefCount)
+		if !f(fd_RedelegationEntry_unbonding_on_hold_ref_count, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_RedelegationEntry) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntry.creation_height":
+		return x.CreationHeight != int64(0)
+	case "cosmos.staking.v1beta1.RedelegationEntry.completion_time":
+		return x.CompletionTime != nil
+	case "cosmos.staking.v1beta1.RedelegationEntry.initial_balance":
+		return x.InitialBalance != ""
+	case "cosmos.staking.v1beta1.RedelegationEntry.shares_dst":
+		return x.SharesDst != ""
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_id":
+		return x.UnbondingId != uint64(0)
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_on_hold_ref_count":
+		return x.UnbondingOnHoldRefCount != int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationEntry) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntry.creation_height":
+		x.CreationHeight = int64(0)
+	case "cosmos.staking.v1beta1.RedelegationEntry.completion_time":
+		x.CompletionTime = nil
+	case "cosmos.staking.v1beta1.RedelegationEntry.initial_balance":
+		x.InitialBalance = ""
+	case "cosmos.staking.v1beta1.RedelegationEntry.shares_dst":
+		x.SharesDst = ""
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_id":
+		x.UnbondingId = uint64(0)
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_on_hold_ref_count":
+		x.UnbondingOnHoldRefCount = int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_RedelegationEntry) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntry.creation_height":
+		value := x.CreationHeight
+		return protoreflect.ValueOfInt64(value)
+	case "cosmos.staking.v1beta1.RedelegationEntry.completion_time":
+		value := x.CompletionTime
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.RedelegationEntry.initial_balance":
+		value := x.InitialBalance
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.RedelegationEntry.shares_dst":
+		value := x.SharesDst
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_id":
+		value := x.UnbondingId
+		return protoreflect.ValueOfUint64(value)
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_on_hold_ref_count":
+		value := x.UnbondingOnHoldRefCount
+		return protoreflect.ValueOfInt64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntry does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationEntry) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntry.creation_height":
+		x.CreationHeight = value.Int()
+	case "cosmos.staking.v1beta1.RedelegationEntry.completion_time":
+		x.CompletionTime = value.Message().Interface().(*timestamppb.Timestamp)
+	case "cosmos.staking.v1beta1.RedelegationEntry.initial_balance":
+		x.InitialBalance = value.Interface().(string)
+	case "cosmos.staking.v1beta1.RedelegationEntry.shares_dst":
+		x.SharesDst = value.Interface().(string)
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_id":
+		x.UnbondingId = value.Uint()
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_on_hold_ref_count":
+		x.UnbondingOnHoldRefCount = value.Int()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationEntry) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntry.completion_time":
+		if x.CompletionTime == nil {
+			x.CompletionTime = new(timestamppb.Timestamp)
+		}
+		return protoreflect.ValueOfMessage(x.CompletionTime.ProtoReflect())
+	case "cosmos.staking.v1beta1.RedelegationEntry.creation_height":
+		panic(fmt.Errorf("field creation_height of message cosmos.staking.v1beta1.RedelegationEntry is not mutable"))
+	case "cosmos.staking.v1beta1.RedelegationEntry.initial_balance":
+		panic(fmt.Errorf("field initial_balance of message cosmos.staking.v1beta1.RedelegationEntry is not mutable"))
+	case "cosmos.staking.v1beta1.RedelegationEntry.shares_dst":
+		panic(fmt.Errorf("field shares_dst of message cosmos.staking.v1beta1.RedelegationEntry is not mutable"))
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_id":
+		panic(fmt.Errorf("field unbonding_id of message cosmos.staking.v1beta1.RedelegationEntry is not mutable"))
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_on_hold_ref_count":
+		panic(fmt.Errorf("field unbonding_on_hold_ref_count of message cosmos.staking.v1beta1.RedelegationEntry is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_RedelegationEntry) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntry.creation_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "cosmos.staking.v1beta1.RedelegationEntry.completion_time":
+		m := new(timestamppb.Timestamp)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.RedelegationEntry.initial_balance":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.RedelegationEntry.shares_dst":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_id":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "cosmos.staking.v1beta1.RedelegationEntry.unbonding_on_hold_ref_count":
+		return protoreflect.ValueOfInt64(int64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntry"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_RedelegationEntry) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.RedelegationEntry", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_RedelegationEntry) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationEntry) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_RedelegationEntry) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_RedelegationEntry) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*RedelegationEntry)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.CreationHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.CreationHeight))
+		}
+		if x.CompletionTime != nil {
+			l = options.Size(x.CompletionTime)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.InitialBalance)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.SharesDst)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.UnbondingId != 0 {
+			n += 1 + runtime.Sov(uint64(x.UnbondingId))
+		}
+		if x.UnbondingOnHoldRefCount != 0 {
+			n += 1 + runtime.Sov(uint64(x.UnbondingOnHoldRefCount))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*RedelegationEntry)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.UnbondingOnHoldRefCount != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.UnbondingOnHoldRefCount))
+			i--
+			dAtA[i] = 0x30
+		}
+		if x.UnbondingId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.UnbondingId))
+			i--
+			dAtA[i] = 0x28
+		}
+		if len(x.SharesDst) > 0 {
+			i -= len(x.SharesDst)
+			copy(dAtA[i:], x.SharesDst)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SharesDst)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.InitialBalance) > 0 {
+			i -= len(x.InitialBalance)
+			copy(dAtA[i:], x.InitialBalance)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InitialBalance)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.CompletionTime != nil {
+			encoded, err := options.Marshal(x.CompletionTime)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.CreationHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.CreationHeight))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*RedelegationEntry)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: RedelegationEntry: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: RedelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType)
+				}
+				x.CreationHeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.CreationHeight |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.CompletionTime == nil {
+					x.CompletionTime = &timestamppb.Timestamp{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CompletionTime); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.InitialBalance = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SharesDst", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.SharesDst = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 5:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingId", wireType)
+				}
+				x.UnbondingId = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.UnbondingId |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 6:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingOnHoldRefCount", wireType)
+				}
+				x.UnbondingOnHoldRefCount = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.UnbondingOnHoldRefCount |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_Redelegation_4_list)(nil)
+
+type _Redelegation_4_list struct {
+	list *[]*RedelegationEntry
+}
+
+func (x *_Redelegation_4_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_Redelegation_4_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_Redelegation_4_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*RedelegationEntry)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_Redelegation_4_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*RedelegationEntry)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_Redelegation_4_list) AppendMutable() protoreflect.Value {
+	v := new(RedelegationEntry)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_Redelegation_4_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_Redelegation_4_list) NewElement() protoreflect.Value {
+	v := new(RedelegationEntry)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_Redelegation_4_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_Redelegation                       protoreflect.MessageDescriptor
+	fd_Redelegation_delegator_address     protoreflect.FieldDescriptor
+	fd_Redelegation_validator_src_address protoreflect.FieldDescriptor
+	fd_Redelegation_validator_dst_address protoreflect.FieldDescriptor
+	fd_Redelegation_entries               protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_Redelegation = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("Redelegation")
+	fd_Redelegation_delegator_address = md_Redelegation.Fields().ByName("delegator_address")
+	fd_Redelegation_validator_src_address = md_Redelegation.Fields().ByName("validator_src_address")
+	fd_Redelegation_validator_dst_address = md_Redelegation.Fields().ByName("validator_dst_address")
+	fd_Redelegation_entries = md_Redelegation.Fields().ByName("entries")
+}
+
+var _ protoreflect.Message = (*fastReflection_Redelegation)(nil)
+
+type fastReflection_Redelegation Redelegation
+
+func (x *Redelegation) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_Redelegation)(x)
+}
+
+func (x *Redelegation) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_Redelegation_messageType fastReflection_Redelegation_messageType
+var _ protoreflect.MessageType = fastReflection_Redelegation_messageType{}
+
+type fastReflection_Redelegation_messageType struct{}
+
+func (x fastReflection_Redelegation_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_Redelegation)(nil)
+}
+func (x fastReflection_Redelegation_messageType) New() protoreflect.Message {
+	return new(fastReflection_Redelegation)
+}
+func (x fastReflection_Redelegation_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_Redelegation
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Redelegation) Descriptor() protoreflect.MessageDescriptor {
+	return md_Redelegation
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_Redelegation) Type() protoreflect.MessageType {
+	return _fastReflection_Redelegation_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Redelegation) New() protoreflect.Message {
+	return new(fastReflection_Redelegation)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Redelegation) Interface() protoreflect.ProtoMessage {
+	return (*Redelegation)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_Redelegation) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddress != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddress)
+		if !f(fd_Redelegation_delegator_address, value) {
+			return
+		}
+	}
+	if x.ValidatorSrcAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorSrcAddress)
+		if !f(fd_Redelegation_validator_src_address, value) {
+			return
+		}
+	}
+	if x.ValidatorDstAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorDstAddress)
+		if !f(fd_Redelegation_validator_dst_address, value) {
+			return
+		}
+	}
+	if len(x.Entries) != 0 {
+		value := protoreflect.ValueOfList(&_Redelegation_4_list{list: &x.Entries})
+		if !f(fd_Redelegation_entries, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_Redelegation) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Redelegation.delegator_address":
+		return x.DelegatorAddress != ""
+	case "cosmos.staking.v1beta1.Redelegation.validator_src_address":
+		return x.ValidatorSrcAddress != ""
+	case "cosmos.staking.v1beta1.Redelegation.validator_dst_address":
+		return x.ValidatorDstAddress != ""
+	case "cosmos.staking.v1beta1.Redelegation.entries":
+		return len(x.Entries) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Redelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Redelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Redelegation) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Redelegation.delegator_address":
+		x.DelegatorAddress = ""
+	case "cosmos.staking.v1beta1.Redelegation.validator_src_address":
+		x.ValidatorSrcAddress = ""
+	case "cosmos.staking.v1beta1.Redelegation.validator_dst_address":
+		x.ValidatorDstAddress = ""
+	case "cosmos.staking.v1beta1.Redelegation.entries":
+		x.Entries = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Redelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Redelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_Redelegation) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.Redelegation.delegator_address":
+		value := x.DelegatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Redelegation.validator_src_address":
+		value := x.ValidatorSrcAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Redelegation.validator_dst_address":
+		value := x.ValidatorDstAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Redelegation.entries":
+		if len(x.Entries) == 0 {
+			return protoreflect.ValueOfList(&_Redelegation_4_list{})
+		}
+		listValue := &_Redelegation_4_list{list: &x.Entries}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Redelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Redelegation does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Redelegation) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Redelegation.delegator_address":
+		x.DelegatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Redelegation.validator_src_address":
+		x.ValidatorSrcAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Redelegation.validator_dst_address":
+		x.ValidatorDstAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Redelegation.entries":
+		lv := value.List()
+		clv := lv.(*_Redelegation_4_list)
+		x.Entries = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Redelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Redelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Redelegation) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Redelegation.entries":
+		if x.Entries == nil {
+			x.Entries = []*RedelegationEntry{}
+		}
+		value := &_Redelegation_4_list{list: &x.Entries}
+		return protoreflect.ValueOfList(value)
+	case "cosmos.staking.v1beta1.Redelegation.delegator_address":
+		panic(fmt.Errorf("field delegator_address of message cosmos.staking.v1beta1.Redelegation is not mutable"))
+	case "cosmos.staking.v1beta1.Redelegation.validator_src_address":
+		panic(fmt.Errorf("field validator_src_address of message cosmos.staking.v1beta1.Redelegation is not mutable"))
+	case "cosmos.staking.v1beta1.Redelegation.validator_dst_address":
+		panic(fmt.Errorf("field validator_dst_address of message cosmos.staking.v1beta1.Redelegation is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Redelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Redelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_Redelegation) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Redelegation.delegator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Redelegation.validator_src_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Redelegation.validator_dst_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Redelegation.entries":
+		list := []*RedelegationEntry{}
+		return protoreflect.ValueOfList(&_Redelegation_4_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Redelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Redelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_Redelegation) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.Redelegation", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_Redelegation) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Redelegation) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_Redelegation) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_Redelegation) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*Redelegation)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorSrcAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorDstAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.Entries) > 0 {
+			for _, e := range x.Entries {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*Redelegation)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Entries) > 0 {
+			for iNdEx := len(x.Entries) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Entries[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x22
+			}
+		}
+		if len(x.ValidatorDstAddress) > 0 {
+			i -= len(x.ValidatorDstAddress)
+			copy(dAtA[i:], x.ValidatorDstAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorDstAddress)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.ValidatorSrcAddress) > 0 {
+			i -= len(x.ValidatorSrcAddress)
+			copy(dAtA[i:], x.ValidatorSrcAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorSrcAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddress) > 0 {
+			i -= len(x.DelegatorAddress)
+			copy(dAtA[i:], x.DelegatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddress)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*Redelegation)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Redelegation: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Redelegation: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorSrcAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorSrcAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorDstAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorDstAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Entries = append(x.Entries, &RedelegationEntry{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Entries[len(x.Entries)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_Params                     protoreflect.MessageDescriptor
+	fd_Params_unbonding_time      protoreflect.FieldDescriptor
+	fd_Params_max_validators      protoreflect.FieldDescriptor
+	fd_Params_max_entries         protoreflect.FieldDescriptor
+	fd_Params_historical_entries  protoreflect.FieldDescriptor
+	fd_Params_bond_denom          protoreflect.FieldDescriptor
+	fd_Params_min_commission_rate protoreflect.FieldDescriptor
+	fd_Params_max_commission_rate protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_Params = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("Params")
+	fd_Params_unbonding_time = md_Params.Fields().ByName("unbonding_time")
+	fd_Params_max_validators = md_Params.Fields().ByName("max_validators")
+	fd_Params_max_entries = md_Params.Fields().ByName("max_entries")
+	fd_Params_historical_entries = md_Params.Fields().ByName("historical_entries")
+	fd_Params_bond_denom = md_Params.Fields().ByName("bond_denom")
+	fd_Params_min_commission_rate = md_Params.Fields().ByName("min_commission_rate")
+	fd_Params_max_commission_rate = md_Params.Fields().ByName("max_commission_rate")
+}
+
+var _ protoreflect.Message = (*fastReflection_Params)(nil)
+
+type fastReflection_Params Params
+
+func (x *Params) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_Params)(x)
+}
+
+func (x *Params) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_Params_messageType fastReflection_Params_messageType
+var _ protoreflect.MessageType = fastReflection_Params_messageType{}
+
+type fastReflection_Params_messageType struct{}
+
+func (x fastReflection_Params_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_Params)(nil)
+}
+func (x fastReflection_Params_messageType) New() protoreflect.Message {
+	return new(fastReflection_Params)
+}
+func (x fastReflection_Params_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_Params
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Params) Descriptor() protoreflect.MessageDescriptor {
+	return md_Params
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_Params) Type() protoreflect.MessageType {
+	return _fastReflection_Params_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Params) New() protoreflect.Message {
+	return new(fastReflection_Params)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Params) Interface() protoreflect.ProtoMessage {
+	return (*Params)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_Params) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.UnbondingTime != nil {
+		value := protoreflect.ValueOfMessage(x.UnbondingTime.ProtoReflect())
+		if !f(fd_Params_unbonding_time, value) {
+			return
+		}
+	}
+	if x.MaxValidators != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.MaxValidators)
+		if !f(fd_Params_max_validators, value) {
+			return
+		}
+	}
+	if x.MaxEntries != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.MaxEntries)
+		if !f(fd_Params_max_entries, value) {
+			return
+		}
+	}
+	if x.HistoricalEntries != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.HistoricalEntries)
+		if !f(fd_Params_historical_entries, value) {
+			return
+		}
+	}
+	if x.BondDenom != "" {
+		value := protoreflect.ValueOfString(x.BondDenom)
+		if !f(fd_Params_bond_denom, value) {
+			return
+		}
+	}
+	if x.MinCommissionRate != "" {
+		value := protoreflect.ValueOfString(x.MinCommissionRate)
+		if !f(fd_Params_min_commission_rate, value) {
+			return
+		}
+	}
+	if x.MaxCommissionRate != "" {
+		value := protoreflect.ValueOfString(x.MaxCommissionRate)
+		if !f(fd_Params_max_commission_rate, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_Params) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Params.unbonding_time":
+		return x.UnbondingTime != nil
+	case "cosmos.staking.v1beta1.Params.max_validators":
+		return x.MaxValidators != uint32(0)
+	case "cosmos.staking.v1beta1.Params.max_entries":
+		return x.MaxEntries != uint32(0)
+	case "cosmos.staking.v1beta1.Params.historical_entries":
+		return x.HistoricalEntries != uint32(0)
+	case "cosmos.staking.v1beta1.Params.bond_denom":
+		return x.BondDenom != ""
+	case "cosmos.staking.v1beta1.Params.min_commission_rate":
+		return x.MinCommissionRate != ""
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		return x.MaxCommissionRate != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Params does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Params) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Params.unbonding_time":
+		x.UnbondingTime = nil
+	case "cosmos.staking.v1beta1.Params.max_validators":
+		x.MaxValidators = uint32(0)
+	case "cosmos.staking.v1beta1.Params.max_entries":
+		x.MaxEntries = uint32(0)
+	case "cosmos.staking.v1beta1.Params.historical_entries":
+		x.HistoricalEntries = uint32(0)
+	case "cosmos.staking.v1beta1.Params.bond_denom":
+		x.BondDenom = ""
+	case "cosmos.staking.v1beta1.Params.min_commission_rate":
+		x.MinCommissionRate = ""
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		x.MaxCommissionRate = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Params does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_Params) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.Params.unbonding_time":
+		value := x.UnbondingTime
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.Params.max_validators":
+		value := x.MaxValidators
+		return protoreflect.ValueOfUint32(value)
+	case "cosmos.staking.v1beta1.Params.max_entries":
+		value := x.MaxEntries
+		return protoreflect.ValueOfUint32(value)
+	case "cosmos.staking.v1beta1.Params.historical_entries":
+		value := x.HistoricalEntries
+		return protoreflect.ValueOfUint32(value)
+	case "cosmos.staking.v1beta1.Params.bond_denom":
+		value := x.BondDenom
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Params.min_commission_rate":
+		value := x.MinCommissionRate
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		value := x.MaxCommissionRate
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Params does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Params) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Params.unbonding_time":
+		x.UnbondingTime = value.Message().Interface().(*durationpb.Duration)
+	case "cosmos.staking.v1beta1.Params.max_validators":
+		x.MaxValidators = uint32(value.Uint())
+	case "cosmos.staking.v1beta1.Params.max_entries":
+		x.MaxEntries = uint32(value.Uint())
+	case "cosmos.staking.v1beta1.Params.historical_entries":
+		x.HistoricalEntries = uint32(value.Uint())
+	case "cosmos.staking.v1beta1.Params.bond_denom":
+		x.BondDenom = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Params.min_commission_rate":
+		x.MinCommissionRate = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		x.MaxCommissionRate = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Params does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Params) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Params.unbonding_time":
+		if x.UnbondingTime == nil {
+			x.UnbondingTime = new(durationpb.Duration)
+		}
+		return protoreflect.ValueOfMessage(x.UnbondingTime.ProtoReflect())
+	case "cosmos.staking.v1beta1.Params.max_validators":
+		panic(fmt.Errorf("field max_validators of message cosmos.staking.v1beta1.Params is not mutable"))
+	case "cosmos.staking.v1beta1.Params.max_entries":
+		panic(fmt.Errorf("field max_entries of message cosmos.staking.v1beta1.Params is not mutable"))
+	case "cosmos.staking.v1beta1.Params.historical_entries":
+		panic(fmt.Errorf("field historical_entries of message cosmos.staking.v1beta1.Params is not mutable"))
+	case "cosmos.staking.v1beta1.Params.bond_denom":
+		panic(fmt.Errorf("field bond_denom of message cosmos.staking.v1beta1.Params is not mutable"))
+	case "cosmos.staking.v1beta1.Params.min_commission_rate":
+		panic(fmt.Errorf("field min_commission_rate of message cosmos.staking.v1beta1.Params is not mutable"))
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		panic(fmt.Errorf("field max_commission_rate of message cosmos.staking.v1beta1.Params is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Params does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_Params) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Params.unbonding_time":
+		m := new(durationpb.Duration)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.Params.max_validators":
+		return protoreflect.ValueOfUint32(uint32(0))
+	case "cosmos.staking.v1beta1.Params.max_entries":
+		return protoreflect.ValueOfUint32(uint32(0))
+	case "cosmos.staking.v1beta1.Params.historical_entries":
+		return protoreflect.ValueOfUint32(uint32(0))
+	case "cosmos.staking.v1beta1.Params.bond_denom":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Params.min_commission_rate":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Params.max_commission_rate":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Params"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Params does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_Params) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.Params", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_Params) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Params) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_Params) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*Params)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.UnbondingTime != nil {
+			l = options.Size(x.UnbondingTime)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.MaxValidators != 0 {
+			n += 1 + runtime.Sov(uint64(x.MaxValidators))
+		}
+		if x.MaxEntries != 0 {
+			n += 1 + runtime.Sov(uint64(x.MaxEntries))
+		}
+		if x.HistoricalEntries != 0 {
+			n += 1 + runtime.Sov(uint64(x.HistoricalEntries))
+		}
+		l = len(x.BondDenom)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.MinCommissionRate)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.MaxCommissionRate)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*Params)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.MaxCommissionRate) > 0 {
+			i -= len(x.MaxCommissionRate)
+			copy(dAtA[i:], x.MaxCommissionRate)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MaxCommissionRate)))
+			i--
+			dAtA[i] = 0x3a
+		}
+		if len(x.MinCommissionRate) > 0 {
+			i -= len(x.MinCommissionRate)
+			copy(dAtA[i:], x.MinCommissionRate)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MinCommissionRate)))
+			i--
+			dAtA[i] = 0x32
+		}
+		if len(x.BondDenom) > 0 {
+			i -= len(x.BondDenom)
+			copy(dAtA[i:], x.BondDenom)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BondDenom)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if x.HistoricalEntries != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.HistoricalEntries))
+			i--
+			dAtA[i] = 0x20
+		}
+		if x.MaxEntries != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.MaxEntries))
+			i--
+			dAtA[i] = 0x18
+		}
+		if x.MaxValidators != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.MaxValidators))
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.UnbondingTime != nil {
+			encoded, err := options.Marshal(x.UnbondingTime)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*Params)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Params: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.UnbondingTime == nil {
+					x.UnbondingTime = &durationpb.Duration{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.UnbondingTime); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaxValidators", wireType)
+				}
+				x.MaxValidators = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.MaxValidators |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaxEntries", wireType)
+				}
+				x.MaxEntries = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.MaxEntries |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HistoricalEntries", wireType)
+				}
+				x.HistoricalEntries = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.HistoricalEntries |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BondDenom", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.BondDenom = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 6:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MinCommissionRate", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.MinCommissionRate = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 7:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaxCommissionRate", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.MaxCommissionRate = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_DelegationResponse            protoreflect.MessageDescriptor
+	fd_DelegationResponse_delegation protoreflect.FieldDescriptor
+	fd_DelegationResponse_balance    protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_DelegationResponse = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("DelegationResponse")
+	fd_DelegationResponse_delegation = md_DelegationResponse.Fields().ByName("delegation")
+	fd_DelegationResponse_balance = md_DelegationResponse.Fields().ByName("balance")
+}
+
+var _ protoreflect.Message = (*fastReflection_DelegationResponse)(nil)
+
+type fastReflection_DelegationResponse DelegationResponse
+
+func (x *DelegationResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_DelegationResponse)(x)
+}
+
+func (x *DelegationResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_DelegationResponse_messageType fastReflection_DelegationResponse_messageType
+var _ protoreflect.MessageType = fastReflection_DelegationResponse_messageType{}
+
+type fastReflection_DelegationResponse_messageType struct{}
+
+func (x fastReflection_DelegationResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_DelegationResponse)(nil)
+}
+func (x fastReflection_DelegationResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_DelegationResponse)
+}
+func (x fastReflection_DelegationResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_DelegationResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_DelegationResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_DelegationResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_DelegationResponse) Type() protoreflect.MessageType {
+	return _fastReflection_DelegationResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_DelegationResponse) New() protoreflect.Message {
+	return new(fastReflection_DelegationResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_DelegationResponse) Interface() protoreflect.ProtoMessage {
+	return (*DelegationResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_DelegationResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Delegation != nil {
+		value := protoreflect.ValueOfMessage(x.Delegation.ProtoReflect())
+		if !f(fd_DelegationResponse_delegation, value) {
+			return
+		}
+	}
+	if x.Balance != nil {
+		value := protoreflect.ValueOfMessage(x.Balance.ProtoReflect())
+		if !f(fd_DelegationResponse_balance, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_DelegationResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DelegationResponse.delegation":
+		return x.Delegation != nil
+	case "cosmos.staking.v1beta1.DelegationResponse.balance":
+		return x.Balance != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DelegationResponse.delegation":
+		x.Delegation = nil
+	case "cosmos.staking.v1beta1.DelegationResponse.balance":
+		x.Balance = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_DelegationResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.DelegationResponse.delegation":
+		value := x.Delegation
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.DelegationResponse.balance":
+		value := x.Balance
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DelegationResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DelegationResponse.delegation":
+		x.Delegation = value.Message().Interface().(*Delegation)
+	case "cosmos.staking.v1beta1.DelegationResponse.balance":
+		x.Balance = value.Message().Interface().(*v1beta1.Coin)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DelegationResponse.delegation":
+		if x.Delegation == nil {
+			x.Delegation = new(Delegation)
+		}
+		return protoreflect.ValueOfMessage(x.Delegation.ProtoReflect())
+	case "cosmos.staking.v1beta1.DelegationResponse.balance":
+		if x.Balance == nil {
+			x.Balance = new(v1beta1.Coin)
+		}
+		return protoreflect.ValueOfMessage(x.Balance.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_DelegationResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.DelegationResponse.delegation":
+		m := new(Delegation)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.DelegationResponse.balance":
+		m := new(v1beta1.Coin)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.DelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.DelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_DelegationResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.DelegationResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_DelegationResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_DelegationResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_DelegationResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*DelegationResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Delegation != nil {
+			l = options.Size(x.Delegation)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Balance != nil {
+			l = options.Size(x.Balance)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*DelegationResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Balance != nil {
+			encoded, err := options.Marshal(x.Balance)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.Delegation != nil {
+			encoded, err := options.Marshal(x.Delegation)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*DelegationResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DelegationResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Delegation", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Delegation == nil {
+					x.Delegation = &Delegation{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Delegation); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Balance == nil {
+					x.Balance = &v1beta1.Coin{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Balance); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_RedelegationEntryResponse                    protoreflect.MessageDescriptor
+	fd_RedelegationEntryResponse_redelegation_entry protoreflect.FieldDescriptor
+	fd_RedelegationEntryResponse_balance            protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_RedelegationEntryResponse = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("RedelegationEntryResponse")
+	fd_RedelegationEntryResponse_redelegation_entry = md_RedelegationEntryResponse.Fields().ByName("redelegation_entry")
+	fd_RedelegationEntryResponse_balance = md_RedelegationEntryResponse.Fields().ByName("balance")
+}
+
+var _ protoreflect.Message = (*fastReflection_RedelegationEntryResponse)(nil)
+
+type fastReflection_RedelegationEntryResponse RedelegationEntryResponse
+
+func (x *RedelegationEntryResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_RedelegationEntryResponse)(x)
+}
+
+func (x *RedelegationEntryResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_RedelegationEntryResponse_messageType fastReflection_RedelegationEntryResponse_messageType
+var _ protoreflect.MessageType = fastReflection_RedelegationEntryResponse_messageType{}
+
+type fastReflection_RedelegationEntryResponse_messageType struct{}
+
+func (x fastReflection_RedelegationEntryResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_RedelegationEntryResponse)(nil)
+}
+func (x fastReflection_RedelegationEntryResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_RedelegationEntryResponse)
+}
+func (x fastReflection_RedelegationEntryResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_RedelegationEntryResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_RedelegationEntryResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_RedelegationEntryResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_RedelegationEntryResponse) Type() protoreflect.MessageType {
+	return _fastReflection_RedelegationEntryResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_RedelegationEntryResponse) New() protoreflect.Message {
+	return new(fastReflection_RedelegationEntryResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_RedelegationEntryResponse) Interface() protoreflect.ProtoMessage {
+	return (*RedelegationEntryResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_RedelegationEntryResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.RedelegationEntry != nil {
+		value := protoreflect.ValueOfMessage(x.RedelegationEntry.ProtoReflect())
+		if !f(fd_RedelegationEntryResponse_redelegation_entry, value) {
+			return
+		}
+	}
+	if x.Balance != "" {
+		value := protoreflect.ValueOfString(x.Balance)
+		if !f(fd_RedelegationEntryResponse_balance, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_RedelegationEntryResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.redelegation_entry":
+		return x.RedelegationEntry != nil
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.balance":
+		return x.Balance != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntryResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntryResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationEntryResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.redelegation_entry":
+		x.RedelegationEntry = nil
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.balance":
+		x.Balance = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntryResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntryResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_RedelegationEntryResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.redelegation_entry":
+		value := x.RedelegationEntry
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.balance":
+		value := x.Balance
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntryResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntryResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationEntryResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.redelegation_entry":
+		x.RedelegationEntry = value.Message().Interface().(*RedelegationEntry)
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.balance":
+		x.Balance = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntryResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntryResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationEntryResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.redelegation_entry":
+		if x.RedelegationEntry == nil {
+			x.RedelegationEntry = new(RedelegationEntry)
+		}
+		return protoreflect.ValueOfMessage(x.RedelegationEntry.ProtoReflect())
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.balance":
+		panic(fmt.Errorf("field balance of message cosmos.staking.v1beta1.RedelegationEntryResponse is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntryResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntryResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_RedelegationEntryResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.redelegation_entry":
+		m := new(RedelegationEntry)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.RedelegationEntryResponse.balance":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationEntryResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationEntryResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_RedelegationEntryResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.RedelegationEntryResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_RedelegationEntryResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationEntryResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_RedelegationEntryResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_RedelegationEntryResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*RedelegationEntryResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.RedelegationEntry != nil {
+			l = options.Size(x.RedelegationEntry)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Balance)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*RedelegationEntryResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Balance) > 0 {
+			i -= len(x.Balance)
+			copy(dAtA[i:], x.Balance)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Balance)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if x.RedelegationEntry != nil {
+			encoded, err := options.Marshal(x.RedelegationEntry)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*RedelegationEntryResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: RedelegationEntryResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: RedelegationEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RedelegationEntry", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.RedelegationEntry == nil {
+					x.RedelegationEntry = &RedelegationEntry{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.RedelegationEntry); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Balance = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_RedelegationResponse_2_list)(nil)
+
+type _RedelegationResponse_2_list struct {
+	list *[]*RedelegationEntryResponse
+}
+
+func (x *_RedelegationResponse_2_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_RedelegationResponse_2_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_RedelegationResponse_2_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*RedelegationEntryResponse)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_RedelegationResponse_2_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*RedelegationEntryResponse)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_RedelegationResponse_2_list) AppendMutable() protoreflect.Value {
+	v := new(RedelegationEntryResponse)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_RedelegationResponse_2_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_RedelegationResponse_2_list) NewElement() protoreflect.Value {
+	v := new(RedelegationEntryResponse)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_RedelegationResponse_2_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_RedelegationResponse              protoreflect.MessageDescriptor
+	fd_RedelegationResponse_redelegation protoreflect.FieldDescriptor
+	fd_RedelegationResponse_entries      protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_RedelegationResponse = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("RedelegationResponse")
+	fd_RedelegationResponse_redelegation = md_RedelegationResponse.Fields().ByName("redelegation")
+	fd_RedelegationResponse_entries = md_RedelegationResponse.Fields().ByName("entries")
+}
+
+var _ protoreflect.Message = (*fastReflection_RedelegationResponse)(nil)
+
+type fastReflection_RedelegationResponse RedelegationResponse
+
+func (x *RedelegationResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_RedelegationResponse)(x)
+}
+
+func (x *RedelegationResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_RedelegationResponse_messageType fastReflection_RedelegationResponse_messageType
+var _ protoreflect.MessageType = fastReflection_RedelegationResponse_messageType{}
+
+type fastReflection_RedelegationResponse_messageType struct{}
+
+func (x fastReflection_RedelegationResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_RedelegationResponse)(nil)
+}
+func (x fastReflection_RedelegationResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_RedelegationResponse)
+}
+func (x fastReflection_RedelegationResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_RedelegationResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_RedelegationResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_RedelegationResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_RedelegationResponse) Type() protoreflect.MessageType {
+	return _fastReflection_RedelegationResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_RedelegationResponse) New() protoreflect.Message {
+	return new(fastReflection_RedelegationResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_RedelegationResponse) Interface() protoreflect.ProtoMessage {
+	return (*RedelegationResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_RedelegationResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Redelegation != nil {
+		value := protoreflect.ValueOfMessage(x.Redelegation.ProtoReflect())
+		if !f(fd_RedelegationResponse_redelegation, value) {
+			return
+		}
+	}
+	if len(x.Entries) != 0 {
+		value := protoreflect.ValueOfList(&_RedelegationResponse_2_list{list: &x.Entries})
+		if !f(fd_RedelegationResponse_entries, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_RedelegationResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationResponse.redelegation":
+		return x.Redelegation != nil
+	case "cosmos.staking.v1beta1.RedelegationResponse.entries":
+		return len(x.Entries) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationResponse.redelegation":
+		x.Redelegation = nil
+	case "cosmos.staking.v1beta1.RedelegationResponse.entries":
+		x.Entries = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_RedelegationResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationResponse.redelegation":
+		value := x.Redelegation
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.RedelegationResponse.entries":
+		if len(x.Entries) == 0 {
+			return protoreflect.ValueOfList(&_RedelegationResponse_2_list{})
+		}
+		listValue := &_RedelegationResponse_2_list{list: &x.Entries}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationResponse.redelegation":
+		x.Redelegation = value.Message().Interface().(*Redelegation)
+	case "cosmos.staking.v1beta1.RedelegationResponse.entries":
+		lv := value.List()
+		clv := lv.(*_RedelegationResponse_2_list)
+		x.Entries = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationResponse.redelegation":
+		if x.Redelegation == nil {
+			x.Redelegation = new(Redelegation)
+		}
+		return protoreflect.ValueOfMessage(x.Redelegation.ProtoReflect())
+	case "cosmos.staking.v1beta1.RedelegationResponse.entries":
+		if x.Entries == nil {
+			x.Entries = []*RedelegationEntryResponse{}
+		}
+		value := &_RedelegationResponse_2_list{list: &x.Entries}
+		return protoreflect.ValueOfList(value)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_RedelegationResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.RedelegationResponse.redelegation":
+		m := new(Redelegation)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.RedelegationResponse.entries":
+		list := []*RedelegationEntryResponse{}
+		return protoreflect.ValueOfList(&_RedelegationResponse_2_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.RedelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.RedelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_RedelegationResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.RedelegationResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_RedelegationResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_RedelegationResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_RedelegationResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_RedelegationResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*RedelegationResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Redelegation != nil {
+			l = options.Size(x.Redelegation)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.Entries) > 0 {
+			for _, e := range x.Entries {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*RedelegationResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Entries) > 0 {
+			for iNdEx := len(x.Entries) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Entries[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x12
+			}
+		}
+		if x.Redelegation != nil {
+			encoded, err := options.Marshal(x.Redelegation)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*RedelegationResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: RedelegationResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: RedelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Redelegation", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Redelegation == nil {
+					x.Redelegation = &Redelegation{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Redelegation); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Entries = append(x.Entries, &RedelegationEntryResponse{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Entries[len(x.Entries)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_Pool                   protoreflect.MessageDescriptor
+	fd_Pool_not_bonded_tokens protoreflect.FieldDescriptor
+	fd_Pool_bonded_tokens     protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_Pool = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("Pool")
+	fd_Pool_not_bonded_tokens = md_Pool.Fields().ByName("not_bonded_tokens")
+	fd_Pool_bonded_tokens = md_Pool.Fields().ByName("bonded_tokens")
+}
+
+var _ protoreflect.Message = (*fastReflection_Pool)(nil)
+
+type fastReflection_Pool Pool
+
+func (x *Pool) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_Pool)(x)
+}
+
+func (x *Pool) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_Pool_messageType fastReflection_Pool_messageType
+var _ protoreflect.MessageType = fastReflection_Pool_messageType{}
+
+type fastReflection_Pool_messageType struct{}
+
+func (x fastReflection_Pool_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_Pool)(nil)
+}
+func (x fastReflection_Pool_messageType) New() protoreflect.Message {
+	return new(fastReflection_Pool)
+}
+func (x fastReflection_Pool_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_Pool
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Pool) Descriptor() protoreflect.MessageDescriptor {
+	return md_Pool
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_Pool) Type() protoreflect.MessageType {
+	return _fastReflection_Pool_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Pool) New() protoreflect.Message {
+	return new(fastReflection_Pool)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Pool) Interface() protoreflect.ProtoMessage {
+	return (*Pool)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_Pool) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.NotBondedTokens != "" {
+		value := protoreflect.ValueOfString(x.NotBondedTokens)
+		if !f(fd_Pool_not_bonded_tokens, value) {
+			return
+		}
+	}
+	if x.BondedTokens != "" {
+		value := protoreflect.ValueOfString(x.BondedTokens)
+		if !f(fd_Pool_bonded_tokens, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_Pool) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Pool.not_bonded_tokens":
+		return x.NotBondedTokens != ""
+	case "cosmos.staking.v1beta1.Pool.bonded_tokens":
+		return x.BondedTokens != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Pool"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Pool does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Pool) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Pool.not_bonded_tokens":
+		x.NotBondedTokens = ""
+	case "cosmos.staking.v1beta1.Pool.bonded_tokens":
+		x.BondedTokens = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Pool"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Pool does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_Pool) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.Pool.not_bonded_tokens":
+		value := x.NotBondedTokens
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.Pool.bonded_tokens":
+		value := x.BondedTokens
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Pool"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Pool does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Pool) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Pool.not_bonded_tokens":
+		x.NotBondedTokens = value.Interface().(string)
+	case "cosmos.staking.v1beta1.Pool.bonded_tokens":
+		x.BondedTokens = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Pool"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Pool does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Pool) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Pool.not_bonded_tokens":
+		panic(fmt.Errorf("field not_bonded_tokens of message cosmos.staking.v1beta1.Pool is not mutable"))
+	case "cosmos.staking.v1beta1.Pool.bonded_tokens":
+		panic(fmt.Errorf("field bonded_tokens of message cosmos.staking.v1beta1.Pool is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Pool"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Pool does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_Pool) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.Pool.not_bonded_tokens":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.Pool.bonded_tokens":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.Pool"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.Pool does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_Pool) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.Pool", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_Pool) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Pool) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_Pool) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_Pool) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*Pool)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.NotBondedTokens)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.BondedTokens)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*Pool)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.BondedTokens) > 0 {
+			i -= len(x.BondedTokens)
+			copy(dAtA[i:], x.BondedTokens)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BondedTokens)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.NotBondedTokens) > 0 {
+			i -= len(x.NotBondedTokens)
+			copy(dAtA[i:], x.NotBondedTokens)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NotBondedTokens)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*Pool)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Pool: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Pool: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NotBondedTokens", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.NotBondedTokens = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BondedTokens", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.BondedTokens = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_ValidatorUpdates_1_list)(nil)
+
+type _ValidatorUpdates_1_list struct {
+	list *[]*abci.ValidatorUpdate
+}
+
+func (x *_ValidatorUpdates_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_ValidatorUpdates_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_ValidatorUpdates_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*abci.ValidatorUpdate)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_ValidatorUpdates_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*abci.ValidatorUpdate)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_ValidatorUpdates_1_list) AppendMutable() protoreflect.Value {
+	v := new(abci.ValidatorUpdate)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ValidatorUpdates_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_ValidatorUpdates_1_list) NewElement() protoreflect.Value {
+	v := new(abci.ValidatorUpdate)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_ValidatorUpdates_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_ValidatorUpdates         protoreflect.MessageDescriptor
+	fd_ValidatorUpdates_updates protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	md_ValidatorUpdates = File_cosmos_staking_v1beta1_staking_proto.Messages().ByName("ValidatorUpdates")
+	fd_ValidatorUpdates_updates = md_ValidatorUpdates.Fields().ByName("updates")
+}
+
+var _ protoreflect.Message = (*fastReflection_ValidatorUpdates)(nil)
+
+type fastReflection_ValidatorUpdates ValidatorUpdates
+
+func (x *ValidatorUpdates) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_ValidatorUpdates)(x)
+}
+
+func (x *ValidatorUpdates) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_ValidatorUpdates_messageType fastReflection_ValidatorUpdates_messageType
+var _ protoreflect.MessageType = fastReflection_ValidatorUpdates_messageType{}
+
+type fastReflection_ValidatorUpdates_messageType struct{}
+
+func (x fastReflection_ValidatorUpdates_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_ValidatorUpdates)(nil)
+}
+func (x fastReflection_ValidatorUpdates_messageType) New() protoreflect.Message {
+	return new(fastReflection_ValidatorUpdates)
+}
+func (x fastReflection_ValidatorUpdates_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_ValidatorUpdates
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ValidatorUpdates) Descriptor() protoreflect.MessageDescriptor {
+	return md_ValidatorUpdates
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_ValidatorUpdates) Type() protoreflect.MessageType {
+	return _fastReflection_ValidatorUpdates_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ValidatorUpdates) New() protoreflect.Message {
+	return new(fastReflection_ValidatorUpdates)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ValidatorUpdates) Interface() protoreflect.ProtoMessage {
+	return (*ValidatorUpdates)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_ValidatorUpdates) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Updates) != 0 {
+		value := protoreflect.ValueOfList(&_ValidatorUpdates_1_list{list: &x.Updates})
+		if !f(fd_ValidatorUpdates_updates, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_ValidatorUpdates) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.ValidatorUpdates.updates":
+		return len(x.Updates) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValidatorUpdates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValidatorUpdates does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ValidatorUpdates) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.ValidatorUpdates.updates":
+		x.Updates = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValidatorUpdates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValidatorUpdates does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_ValidatorUpdates) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.ValidatorUpdates.updates":
+		if len(x.Updates) == 0 {
+			return protoreflect.ValueOfList(&_ValidatorUpdates_1_list{})
+		}
+		listValue := &_ValidatorUpdates_1_list{list: &x.Updates}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValidatorUpdates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValidatorUpdates does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ValidatorUpdates) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.ValidatorUpdates.updates":
+		lv := value.List()
+		clv := lv.(*_ValidatorUpdates_1_list)
+		x.Updates = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValidatorUpdates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValidatorUpdates does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ValidatorUpdates) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.ValidatorUpdates.updates":
+		if x.Updates == nil {
+			x.Updates = []*abci.ValidatorUpdate{}
+		}
+		value := &_ValidatorUpdates_1_list{list: &x.Updates}
+		return protoreflect.ValueOfList(value)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValidatorUpdates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValidatorUpdates does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_ValidatorUpdates) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.ValidatorUpdates.updates":
+		list := []*abci.ValidatorUpdate{}
+		return protoreflect.ValueOfList(&_ValidatorUpdates_1_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.ValidatorUpdates"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.ValidatorUpdates does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_ValidatorUpdates) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.ValidatorUpdates", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_ValidatorUpdates) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ValidatorUpdates) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_ValidatorUpdates) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_ValidatorUpdates) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*ValidatorUpdates)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.Updates) > 0 {
+			for _, e := range x.Updates {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*ValidatorUpdates)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Updates) > 0 {
+			for iNdEx := len(x.Updates) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Updates[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*ValidatorUpdates)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidatorUpdates: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidatorUpdates: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Updates", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Updates = append(x.Updates, &abci.ValidatorUpdate{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Updates[len(x.Updates)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.0
+// 	protoc        (unknown)
+// source: cosmos/staking/v1beta1/staking.proto
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// BondStatus is the status of a validator.
+type BondStatus int32
+
+const (
+	// UNSPECIFIED defines an invalid validator status.
+	BondStatus_BOND_STATUS_UNSPECIFIED BondStatus = 0
+	// UNBONDED defines a validator that is not bonded.
+	BondStatus_BOND_STATUS_UNBONDED BondStatus = 1
+	// UNBONDING defines a validator that is unbonding.
+	BondStatus_BOND_STATUS_UNBONDING BondStatus = 2
+	// BONDED defines a validator that is bonded.
+	BondStatus_BOND_STATUS_BONDED BondStatus = 3
+)
+
+// Enum value maps for BondStatus.
+var (
+	BondStatus_name = map[int32]string{
+		0: "BOND_STATUS_UNSPECIFIED",
+		1: "BOND_STATUS_UNBONDED",
+		2: "BOND_STATUS_UNBONDING",
+		3: "BOND_STATUS_BONDED",
+	}
+	BondStatus_value = map[string]int32{
+		"BOND_STATUS_UNSPECIFIED": 0,
+		"BOND_STATUS_UNBONDED":    1,
+		"BOND_STATUS_UNBONDING":   2,
+		"BOND_STATUS_BONDED":      3,
+	}
+)
+
+func (x BondStatus) Enum() *BondStatus {
+	p := new(BondStatus)
+	*p = x
+	return p
+}
+
+func (x BondStatus) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (BondStatus) Descriptor() protoreflect.EnumDescriptor {
+	return file_cosmos_staking_v1beta1_staking_proto_enumTypes[0].Descriptor()
+}
+
+func (BondStatus) Type() protoreflect.EnumType {
+	return &file_cosmos_staking_v1beta1_staking_proto_enumTypes[0]
+}
+
+func (x BondStatus) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use BondStatus.Descriptor instead.
+func (BondStatus) EnumDescriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{0}
+}
+
+// Infraction indicates the infraction a validator commited.
+type Infraction int32
+
+const (
+	// UNSPECIFIED defines an empty infraction.
+	Infraction_INFRACTION_UNSPECIFIED Infraction = 0
+	// DOUBLE_SIGN defines a validator that double-signs a block.
+	Infraction_INFRACTION_DOUBLE_SIGN Infraction = 1
+	// DOWNTIME defines a validator that missed signing too many blocks.
+	Infraction_INFRACTION_DOWNTIME Infraction = 2
+)
+
+// Enum value maps for Infraction.
+var (
+	Infraction_name = map[int32]string{
+		0: "INFRACTION_UNSPECIFIED",
+		1: "INFRACTION_DOUBLE_SIGN",
+		2: "INFRACTION_DOWNTIME",
+	}
+	Infraction_value = map[string]int32{
+		"INFRACTION_UNSPECIFIED": 0,
+		"INFRACTION_DOUBLE_SIGN": 1,
+		"INFRACTION_DOWNTIME":    2,
+	}
+)
+
+func (x Infraction) Enum() *Infraction {
+	p := new(Infraction)
+	*p = x
+	return p
+}
+
+func (x Infraction) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Infraction) Descriptor() protoreflect.EnumDescriptor {
+	return file_cosmos_staking_v1beta1_staking_proto_enumTypes[1].Descriptor()
+}
+
+func (Infraction) Type() protoreflect.EnumType {
+	return &file_cosmos_staking_v1beta1_staking_proto_enumTypes[1]
+}
+
+func (x Infraction) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use Infraction.Descriptor instead.
+func (Infraction) EnumDescriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{1}
+}
+
+// HistoricalInfo contains header and validator information for a given block.
+// It is stored as part of staking module's state, which persists the `n` most
+// recent HistoricalInfo
+// (`n` is set by the staking module's `historical_entries` parameter).
+type HistoricalInfo struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Header *types.Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
+	Valset []*Validator  `protobuf:"bytes,2,rep,name=valset,proto3" json:"valset,omitempty"`
+}
+
+func (x *HistoricalInfo) Reset() {
+	*x = HistoricalInfo{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *HistoricalInfo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*HistoricalInfo) ProtoMessage() {}
+
+// Deprecated: Use HistoricalInfo.ProtoReflect.Descriptor instead.
+func (*HistoricalInfo) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *HistoricalInfo) GetHeader() *types.Header {
+	if x != nil {
+		return x.Header
+	}
+	return nil
+}
+
+func (x *HistoricalInfo) GetValset() []*Validator {
+	if x != nil {
+		return x.Valset
+	}
+	return nil
+}
+
+// CommissionRates defines the initial commission rates to be used for creating
+// a validator.
+type CommissionRates struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// rate is the commission rate charged to delegators, as a fraction.
+	Rate string `protobuf:"bytes,1,opt,name=rate,proto3" json:"rate,omitempty"`
+	// max_rate defines the maximum commission rate which validator can ever charge, as a fraction.
+	MaxRate string `protobuf:"bytes,2,opt,name=max_rate,json=maxRate,proto3" json:"max_rate,omitempty"`
+	// max_change_rate defines the maximum daily increase of the validator commission, as a fraction.
+	MaxChangeRate string `protobuf:"bytes,3,opt,name=max_change_rate,json=maxChangeRate,proto3" json:"max_change_rate,omitempty"`
+}
+
+func (x *CommissionRates) Reset() {
+	*x = CommissionRates{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *CommissionRates) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CommissionRates) ProtoMessage() {}
+
+// Deprecated: Use CommissionRates.ProtoReflect.Descriptor instead.
+func (*CommissionRates) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *CommissionRates) GetRate() string {
+	if x != nil {
+		return x.Rate
+	}
+	return ""
+}
+
+func (x *CommissionRates) GetMaxRate() string {
+	if x != nil {
+		return x.MaxRate
+	}
+	return ""
+}
+
+func (x *CommissionRates) GetMaxChangeRate() string {
+	if x != nil {
+		return x.MaxChangeRate
+	}
+	return ""
+}
+
+// Commission defines commission parameters for a given validator.
+type Commission struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// commission_rates defines the initial commission rates to be used for creating a validator.
+	CommissionRates *CommissionRates `protobuf:"bytes,1,opt,name=commission_rates,json=commissionRates,proto3" json:"commission_rates,omitempty"`
+	// update_time is the last time the commission rate was changed.
+	UpdateTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"`
+}
+
+func (x *Commission) Reset() {
+	*x = Commission{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Commission) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Commission) ProtoMessage() {}
+
+// Deprecated: Use Commission.ProtoReflect.Descriptor instead.
+func (*Commission) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Commission) GetCommissionRates() *CommissionRates {
+	if x != nil {
+		return x.CommissionRates
+	}
+	return nil
+}
+
+func (x *Commission) GetUpdateTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.UpdateTime
+	}
+	return nil
+}
+
+// Description defines a validator description.
+type Description struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// moniker defines a human-readable name for the validator.
+	Moniker string `protobuf:"bytes,1,opt,name=moniker,proto3" json:"moniker,omitempty"`
+	// identity defines an optional identity signature (ex. UPort or Keybase).
+	Identity string `protobuf:"bytes,2,opt,name=identity,proto3" json:"identity,omitempty"`
+	// website defines an optional website link.
+	Website string `protobuf:"bytes,3,opt,name=website,proto3" json:"website,omitempty"`
+	// security_contact defines an optional email for security contact.
+	SecurityContact string `protobuf:"bytes,4,opt,name=security_contact,json=securityContact,proto3" json:"security_contact,omitempty"`
+	// details define other optional details.
+	Details string `protobuf:"bytes,5,opt,name=details,proto3" json:"details,omitempty"`
+}
+
+func (x *Description) Reset() {
+	*x = Description{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Description) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Description) ProtoMessage() {}
+
+// Deprecated: Use Description.ProtoReflect.Descriptor instead.
+func (*Description) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Description) GetMoniker() string {
+	if x != nil {
+		return x.Moniker
+	}
+	return ""
+}
+
+func (x *Description) GetIdentity() string {
+	if x != nil {
+		return x.Identity
+	}
+	return ""
+}
+
+func (x *Description) GetWebsite() string {
+	if x != nil {
+		return x.Website
+	}
+	return ""
+}
+
+func (x *Description) GetSecurityContact() string {
+	if x != nil {
+		return x.SecurityContact
+	}
+	return ""
+}
+
+func (x *Description) GetDetails() string {
+	if x != nil {
+		return x.Details
+	}
+	return ""
+}
+
+// Validator defines a validator, together with the total amount of the
+// Validator's bond shares and their exchange rate to coins. Slashing results in
+// a decrease in the exchange rate, allowing correct calculation of future
+// undelegations without iterating over delegators. When coins are delegated to
+// this validator, the validator is credited with a delegation whose number of
+// bond shares is based on the amount of coins delegated divided by the current
+// exchange rate. Voting power can be calculated as total bonded shares
+// multiplied by exchange rate.
+type Validator struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// operator_address defines the address of the validator's operator; bech encoded in JSON.
+	OperatorAddress string `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty"`
+	// consensus_pubkey is the consensus public key of the validator, as a Protobuf Any.
+	ConsensusPubkey *anypb.Any `protobuf:"bytes,2,opt,name=consensus_pubkey,json=consensusPubkey,proto3" json:"consensus_pubkey,omitempty"`
+	// jailed defined whether the validator has been jailed from bonded status or not.
+	Jailed bool `protobuf:"varint,3,opt,name=jailed,proto3" json:"jailed,omitempty"`
+	// status is the validator status (bonded/unbonding/unbonded).
+	Status BondStatus `protobuf:"varint,4,opt,name=status,proto3,enum=cosmos.staking.v1beta1.BondStatus" json:"status,omitempty"`
+	// tokens define the delegated tokens (incl. self-delegation).
+	Tokens string `protobuf:"bytes,5,opt,name=tokens,proto3" json:"tokens,omitempty"`
+	// delegator_shares defines total shares issued to a validator's delegators.
+	DelegatorShares string `protobuf:"bytes,6,opt,name=delegator_shares,json=delegatorShares,proto3" json:"delegator_shares,omitempty"`
+	// description defines the description terms for the validator.
+	Description *Description `protobuf:"bytes,7,opt,name=description,proto3" json:"description,omitempty"`
+	// unbonding_height defines, if unbonding, the height at which this validator has begun unbonding.
+	UnbondingHeight int64 `protobuf:"varint,8,opt,name=unbonding_height,json=unbondingHeight,proto3" json:"unbonding_height,omitempty"`
+	// unbonding_time defines, if unbonding, the min time for the validator to complete unbonding.
+	UnbondingTime *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=unbonding_time,json=unbondingTime,proto3" json:"unbonding_time,omitempty"`
+	// commission defines the commission parameters.
+	Commission *Commission `protobuf:"bytes,10,opt,name=commission,proto3" json:"commission,omitempty"`
+	// min_self_delegation is the validator's self declared minimum self delegation.
+	//
+	// Since: cosmos-sdk 0.46
+	MinSelfDelegation string `protobuf:"bytes,11,opt,name=min_self_delegation,json=minSelfDelegation,proto3" json:"min_self_delegation,omitempty"`
+	// strictly positive if this validator's unbonding has been stopped by external modules
+	UnbondingOnHoldRefCount int64 `protobuf:"varint,12,opt,name=unbonding_on_hold_ref_count,json=unbondingOnHoldRefCount,proto3" json:"unbonding_on_hold_ref_count,omitempty"`
+	// list of unbonding ids, each uniquely identifing an unbonding of this validator
+	UnbondingIds []uint64 `protobuf:"varint,13,rep,packed,name=unbonding_ids,json=unbondingIds,proto3" json:"unbonding_ids,omitempty"`
+}
+
+func (x *Validator) Reset() {
+	*x = Validator{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Validator) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Validator) ProtoMessage() {}
+
+// Deprecated: Use Validator.ProtoReflect.Descriptor instead.
+func (*Validator) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Validator) GetOperatorAddress() string {
+	if x != nil {
+		return x.OperatorAddress
+	}
+	return ""
+}
+
+func (x *Validator) GetConsensusPubkey() *anypb.Any {
+	if x != nil {
+		return x.ConsensusPubkey
+	}
+	return nil
+}
+
+func (x *Validator) GetJailed() bool {
+	if x != nil {
+		return x.Jailed
+	}
+	return false
+}
+
+func (x *Validator) GetStatus() BondStatus {
+	if x != nil {
+		return x.Status
+	}
+	return BondStatus_BOND_STATUS_UNSPECIFIED
+}
+
+func (x *Validator) GetTokens() string {
+	if x != nil {
+		return x.Tokens
+	}
+	return ""
+}
+
+func (x *Validator) GetDelegatorShares() string {
+	if x != nil {
+		return x.DelegatorShares
+	}
+	return ""
+}
+
+func (x *Validator) GetDescription() *Description {
+	if x != nil {
+		return x.Description
+	}
+	return nil
+}
+
+func (x *Validator) GetUnbondingHeight() int64 {
+	if x != nil {
+		return x.UnbondingHeight
+	}
+	return 0
+}
+
+func (x *Validator) GetUnbondingTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.UnbondingTime
+	}
+	return nil
+}
+
+func (x *Validator) GetCommission() *Commission {
+	if x != nil {
+		return x.Commission
+	}
+	return nil
+}
+
+func (x *Validator) GetMinSelfDelegation() string {
+	if x != nil {
+		return x.MinSelfDelegation
+	}
+	return ""
+}
+
+func (x *Validator) GetUnbondingOnHoldRefCount() int64 {
+	if x != nil {
+		return x.UnbondingOnHoldRefCount
+	}
+	return 0
+}
+
+func (x *Validator) GetUnbondingIds() []uint64 {
+	if x != nil {
+		return x.UnbondingIds
+	}
+	return nil
+}
+
+// ValAddresses defines a repeated set of validator addresses.
+type ValAddresses struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
+}
+
+func (x *ValAddresses) Reset() {
+	*x = ValAddresses{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ValAddresses) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ValAddresses) ProtoMessage() {}
+
+// Deprecated: Use ValAddresses.ProtoReflect.Descriptor instead.
+func (*ValAddresses) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *ValAddresses) GetAddresses() []string {
+	if x != nil {
+		return x.Addresses
+	}
+	return nil
+}
+
+// DVPair is struct that just has a delegator-validator pair with no other data.
+// It is intended to be used as a marshalable pointer. For example, a DVPair can
+// be used to construct the key to getting an UnbondingDelegation from state.
+type DVPair struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"`
+	ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
+}
+
+func (x *DVPair) Reset() {
+	*x = DVPair{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DVPair) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DVPair) ProtoMessage() {}
+
+// Deprecated: Use DVPair.ProtoReflect.Descriptor instead.
+func (*DVPair) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *DVPair) GetDelegatorAddress() string {
+	if x != nil {
+		return x.DelegatorAddress
+	}
+	return ""
+}
+
+func (x *DVPair) GetValidatorAddress() string {
+	if x != nil {
+		return x.ValidatorAddress
+	}
+	return ""
+}
+
+// DVPairs defines an array of DVPair objects.
+type DVPairs struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Pairs []*DVPair `protobuf:"bytes,1,rep,name=pairs,proto3" json:"pairs,omitempty"`
+}
+
+func (x *DVPairs) Reset() {
+	*x = DVPairs{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DVPairs) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DVPairs) ProtoMessage() {}
+
+// Deprecated: Use DVPairs.ProtoReflect.Descriptor instead.
+func (*DVPairs) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *DVPairs) GetPairs() []*DVPair {
+	if x != nil {
+		return x.Pairs
+	}
+	return nil
+}
+
+// DVVTriplet is struct that just has a delegator-validator-validator triplet
+// with no other data. It is intended to be used as a marshalable pointer. For
+// example, a DVVTriplet can be used to construct the key to getting a
+// Redelegation from state.
+type DVVTriplet struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	DelegatorAddress    string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"`
+	ValidatorSrcAddress string `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty"`
+	ValidatorDstAddress string `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty"`
+}
+
+func (x *DVVTriplet) Reset() {
+	*x = DVVTriplet{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DVVTriplet) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DVVTriplet) ProtoMessage() {}
+
+// Deprecated: Use DVVTriplet.ProtoReflect.Descriptor instead.
+func (*DVVTriplet) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *DVVTriplet) GetDelegatorAddress() string {
+	if x != nil {
+		return x.DelegatorAddress
+	}
+	return ""
+}
+
+func (x *DVVTriplet) GetValidatorSrcAddress() string {
+	if x != nil {
+		return x.ValidatorSrcAddress
+	}
+	return ""
+}
+
+func (x *DVVTriplet) GetValidatorDstAddress() string {
+	if x != nil {
+		return x.ValidatorDstAddress
+	}
+	return ""
+}
+
+// DVVTriplets defines an array of DVVTriplet objects.
+type DVVTriplets struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Triplets []*DVVTriplet `protobuf:"bytes,1,rep,name=triplets,proto3" json:"triplets,omitempty"`
+}
+
+func (x *DVVTriplets) Reset() {
+	*x = DVVTriplets{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DVVTriplets) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DVVTriplets) ProtoMessage() {}
+
+// Deprecated: Use DVVTriplets.ProtoReflect.Descriptor instead.
+func (*DVVTriplets) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *DVVTriplets) GetTriplets() []*DVVTriplet {
+	if x != nil {
+		return x.Triplets
+	}
+	return nil
+}
+
+// Delegation represents the bond with tokens held by an account. It is
+// owned by one delegator, and is associated with the voting power of one
+// validator.
+type Delegation struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegator_address is the encoded address of the delegator.
+	DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"`
+	// validator_address is the encoded address of the validator.
+	ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
+	// shares define the delegation shares received.
+	Shares string `protobuf:"bytes,3,opt,name=shares,proto3" json:"shares,omitempty"`
+}
+
+func (x *Delegation) Reset() {
+	*x = Delegation{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Delegation) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Delegation) ProtoMessage() {}
+
+// Deprecated: Use Delegation.ProtoReflect.Descriptor instead.
+func (*Delegation) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *Delegation) GetDelegatorAddress() string {
+	if x != nil {
+		return x.DelegatorAddress
+	}
+	return ""
+}
+
+func (x *Delegation) GetValidatorAddress() string {
+	if x != nil {
+		return x.ValidatorAddress
+	}
+	return ""
+}
+
+func (x *Delegation) GetShares() string {
+	if x != nil {
+		return x.Shares
+	}
+	return ""
+}
+
+// UnbondingDelegation stores all of a single delegator's unbonding bonds
+// for a single validator in an time-ordered list.
+type UnbondingDelegation struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegator_address is the encoded address of the delegator.
+	DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"`
+	// validator_address is the encoded address of the validator.
+	ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
+	// entries are the unbonding delegation entries.
+	Entries []*UnbondingDelegationEntry `protobuf:"bytes,3,rep,name=entries,proto3" json:"entries,omitempty"` // unbonding delegation entries
+}
+
+func (x *UnbondingDelegation) Reset() {
+	*x = UnbondingDelegation{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UnbondingDelegation) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UnbondingDelegation) ProtoMessage() {}
+
+// Deprecated: Use UnbondingDelegation.ProtoReflect.Descriptor instead.
+func (*UnbondingDelegation) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *UnbondingDelegation) GetDelegatorAddress() string {
+	if x != nil {
+		return x.DelegatorAddress
+	}
+	return ""
+}
+
+func (x *UnbondingDelegation) GetValidatorAddress() string {
+	if x != nil {
+		return x.ValidatorAddress
+	}
+	return ""
+}
+
+func (x *UnbondingDelegation) GetEntries() []*UnbondingDelegationEntry {
+	if x != nil {
+		return x.Entries
+	}
+	return nil
+}
+
+// UnbondingDelegationEntry defines an unbonding object with relevant metadata.
+type UnbondingDelegationEntry struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// creation_height is the height which the unbonding took place.
+	CreationHeight int64 `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty"`
+	// completion_time is the unix time for unbonding completion.
+	CompletionTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3" json:"completion_time,omitempty"`
+	// initial_balance defines the tokens initially scheduled to receive at completion.
+	InitialBalance string `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3" json:"initial_balance,omitempty"`
+	// balance defines the tokens to receive at completion.
+	Balance string `protobuf:"bytes,4,opt,name=balance,proto3" json:"balance,omitempty"`
+	// Incrementing id that uniquely identifies this entry
+	UnbondingId uint64 `protobuf:"varint,5,opt,name=unbonding_id,json=unbondingId,proto3" json:"unbonding_id,omitempty"`
+	// Strictly positive if this entry's unbonding has been stopped by external modules
+	UnbondingOnHoldRefCount int64 `protobuf:"varint,6,opt,name=unbonding_on_hold_ref_count,json=unbondingOnHoldRefCount,proto3" json:"unbonding_on_hold_ref_count,omitempty"`
+}
+
+func (x *UnbondingDelegationEntry) Reset() {
+	*x = UnbondingDelegationEntry{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *UnbondingDelegationEntry) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UnbondingDelegationEntry) ProtoMessage() {}
+
+// Deprecated: Use UnbondingDelegationEntry.ProtoReflect.Descriptor instead.
+func (*UnbondingDelegationEntry) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *UnbondingDelegationEntry) GetCreationHeight() int64 {
+	if x != nil {
+		return x.CreationHeight
+	}
+	return 0
+}
+
+func (x *UnbondingDelegationEntry) GetCompletionTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.CompletionTime
+	}
+	return nil
+}
+
+func (x *UnbondingDelegationEntry) GetInitialBalance() string {
+	if x != nil {
+		return x.InitialBalance
+	}
+	return ""
+}
+
+func (x *UnbondingDelegationEntry) GetBalance() string {
+	if x != nil {
+		return x.Balance
+	}
+	return ""
+}
+
+func (x *UnbondingDelegationEntry) GetUnbondingId() uint64 {
+	if x != nil {
+		return x.UnbondingId
+	}
+	return 0
+}
+
+func (x *UnbondingDelegationEntry) GetUnbondingOnHoldRefCount() int64 {
+	if x != nil {
+		return x.UnbondingOnHoldRefCount
+	}
+	return 0
+}
+
+// RedelegationEntry defines a redelegation object with relevant metadata.
+type RedelegationEntry struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// creation_height  defines the height which the redelegation took place.
+	CreationHeight int64 `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty"`
+	// completion_time defines the unix time for redelegation completion.
+	CompletionTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3" json:"completion_time,omitempty"`
+	// initial_balance defines the initial balance when redelegation started.
+	InitialBalance string `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3" json:"initial_balance,omitempty"`
+	// shares_dst is the amount of destination-validator shares created by redelegation.
+	SharesDst string `protobuf:"bytes,4,opt,name=shares_dst,json=sharesDst,proto3" json:"shares_dst,omitempty"`
+	// Incrementing id that uniquely identifies this entry
+	UnbondingId uint64 `protobuf:"varint,5,opt,name=unbonding_id,json=unbondingId,proto3" json:"unbonding_id,omitempty"`
+	// Strictly positive if this entry's unbonding has been stopped by external modules
+	UnbondingOnHoldRefCount int64 `protobuf:"varint,6,opt,name=unbonding_on_hold_ref_count,json=unbondingOnHoldRefCount,proto3" json:"unbonding_on_hold_ref_count,omitempty"`
+}
+
+func (x *RedelegationEntry) Reset() {
+	*x = RedelegationEntry{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RedelegationEntry) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RedelegationEntry) ProtoMessage() {}
+
+// Deprecated: Use RedelegationEntry.ProtoReflect.Descriptor instead.
+func (*RedelegationEntry) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *RedelegationEntry) GetCreationHeight() int64 {
+	if x != nil {
+		return x.CreationHeight
+	}
+	return 0
+}
+
+func (x *RedelegationEntry) GetCompletionTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.CompletionTime
+	}
+	return nil
+}
+
+func (x *RedelegationEntry) GetInitialBalance() string {
+	if x != nil {
+		return x.InitialBalance
+	}
+	return ""
+}
+
+func (x *RedelegationEntry) GetSharesDst() string {
+	if x != nil {
+		return x.SharesDst
+	}
+	return ""
+}
+
+func (x *RedelegationEntry) GetUnbondingId() uint64 {
+	if x != nil {
+		return x.UnbondingId
+	}
+	return 0
+}
+
+func (x *RedelegationEntry) GetUnbondingOnHoldRefCount() int64 {
+	if x != nil {
+		return x.UnbondingOnHoldRefCount
+	}
+	return 0
+}
+
+// Redelegation contains the list of a particular delegator's redelegating bonds
+// from a particular source validator to a particular destination validator.
+type Redelegation struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// delegator_address is the bech32-encoded address of the delegator.
+	DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"`
+	// validator_src_address is the validator redelegation source operator address.
+	ValidatorSrcAddress string `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty"`
+	// validator_dst_address is the validator redelegation destination operator address.
+	ValidatorDstAddress string `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty"`
+	// entries are the redelegation entries.
+	Entries []*RedelegationEntry `protobuf:"bytes,4,rep,name=entries,proto3" json:"entries,omitempty"` // redelegation entries
+}
+
+func (x *Redelegation) Reset() {
+	*x = Redelegation{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Redelegation) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Redelegation) ProtoMessage() {}
+
+// Deprecated: Use Redelegation.ProtoReflect.Descriptor instead.
+func (*Redelegation) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *Redelegation) GetDelegatorAddress() string {
+	if x != nil {
+		return x.DelegatorAddress
+	}
+	return ""
+}
+
+func (x *Redelegation) GetValidatorSrcAddress() string {
+	if x != nil {
+		return x.ValidatorSrcAddress
+	}
+	return ""
+}
+
+func (x *Redelegation) GetValidatorDstAddress() string {
+	if x != nil {
+		return x.ValidatorDstAddress
+	}
+	return ""
+}
+
+func (x *Redelegation) GetEntries() []*RedelegationEntry {
+	if x != nil {
+		return x.Entries
+	}
+	return nil
+}
+
+// Params defines the parameters for the x/staking module.
+type Params struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// unbonding_time is the time duration of unbonding.
+	UnbondingTime *durationpb.Duration `protobuf:"bytes,1,opt,name=unbonding_time,json=unbondingTime,proto3" json:"unbonding_time,omitempty"`
+	// max_validators is the maximum number of validators.
+	MaxValidators uint32 `protobuf:"varint,2,opt,name=max_validators,json=maxValidators,proto3" json:"max_validators,omitempty"`
+	// max_entries is the max entries for either unbonding delegation or redelegation (per pair/trio).
+	MaxEntries uint32 `protobuf:"varint,3,opt,name=max_entries,json=maxEntries,proto3" json:"max_entries,omitempty"`
+	// historical_entries is the number of historical entries to persist.
+	HistoricalEntries uint32 `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty"`
+	// bond_denom defines the bondable coin denomination.
+	BondDenom string `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty"`
+	// min_commission_rate represents the minimum commission rate that a validator can charge their delegators
+	MinCommissionRate string `protobuf:"bytes,6,opt,name=min_commission_rate,json=minCommissionRate,proto3" json:"min_commission_rate,omitempty"`
+	// max_commission_rate represents the maximum commission rate that a validator can charge their delegators
+	MaxCommissionRate string `protobuf:"bytes,7,opt,name=max_commission_rate,json=maxCommissionRate,proto3" json:"max_commission_rate,omitempty"`
+}
+
+func (x *Params) Reset() {
+	*x = Params{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Params) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Params) ProtoMessage() {}
+
+// Deprecated: Use Params.ProtoReflect.Descriptor instead.
+func (*Params) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *Params) GetUnbondingTime() *durationpb.Duration {
+	if x != nil {
+		return x.UnbondingTime
+	}
+	return nil
+}
+
+func (x *Params) GetMaxValidators() uint32 {
+	if x != nil {
+		return x.MaxValidators
+	}
+	return 0
+}
+
+func (x *Params) GetMaxEntries() uint32 {
+	if x != nil {
+		return x.MaxEntries
+	}
+	return 0
+}
+
+func (x *Params) GetHistoricalEntries() uint32 {
+	if x != nil {
+		return x.HistoricalEntries
+	}
+	return 0
+}
+
+func (x *Params) GetBondDenom() string {
+	if x != nil {
+		return x.BondDenom
+	}
+	return ""
+}
+
+func (x *Params) GetMinCommissionRate() string {
+	if x != nil {
+		return x.MinCommissionRate
+	}
+	return ""
+}
+
+func (x *Params) GetMaxCommissionRate() string {
+	if x != nil {
+		return x.MaxCommissionRate
+	}
+	return ""
+}
+
+// DelegationResponse is equivalent to Delegation except that it contains a
+// balance in addition to shares which is more suitable for client responses.
+type DelegationResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Delegation *Delegation   `protobuf:"bytes,1,opt,name=delegation,proto3" json:"delegation,omitempty"`
+	Balance    *v1beta1.Coin `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance,omitempty"`
+}
+
+func (x *DelegationResponse) Reset() {
+	*x = DelegationResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DelegationResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DelegationResponse) ProtoMessage() {}
+
+// Deprecated: Use DelegationResponse.ProtoReflect.Descriptor instead.
+func (*DelegationResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *DelegationResponse) GetDelegation() *Delegation {
+	if x != nil {
+		return x.Delegation
+	}
+	return nil
+}
+
+func (x *DelegationResponse) GetBalance() *v1beta1.Coin {
+	if x != nil {
+		return x.Balance
+	}
+	return nil
+}
+
+// RedelegationEntryResponse is equivalent to a RedelegationEntry except that it
+// contains a balance in addition to shares which is more suitable for client
+// responses.
+type RedelegationEntryResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RedelegationEntry *RedelegationEntry `protobuf:"bytes,1,opt,name=redelegation_entry,json=redelegationEntry,proto3" json:"redelegation_entry,omitempty"`
+	Balance           string             `protobuf:"bytes,4,opt,name=balance,proto3" json:"balance,omitempty"`
+}
+
+func (x *RedelegationEntryResponse) Reset() {
+	*x = RedelegationEntryResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RedelegationEntryResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RedelegationEntryResponse) ProtoMessage() {}
+
+// Deprecated: Use RedelegationEntryResponse.ProtoReflect.Descriptor instead.
+func (*RedelegationEntryResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *RedelegationEntryResponse) GetRedelegationEntry() *RedelegationEntry {
+	if x != nil {
+		return x.RedelegationEntry
+	}
+	return nil
+}
+
+func (x *RedelegationEntryResponse) GetBalance() string {
+	if x != nil {
+		return x.Balance
+	}
+	return ""
+}
+
+// RedelegationResponse is equivalent to a Redelegation except that its entries
+// contain a balance in addition to shares which is more suitable for client
+// responses.
+type RedelegationResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Redelegation *Redelegation                `protobuf:"bytes,1,opt,name=redelegation,proto3" json:"redelegation,omitempty"`
+	Entries      []*RedelegationEntryResponse `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries,omitempty"`
+}
+
+func (x *RedelegationResponse) Reset() {
+	*x = RedelegationResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RedelegationResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RedelegationResponse) ProtoMessage() {}
+
+// Deprecated: Use RedelegationResponse.ProtoReflect.Descriptor instead.
+func (*RedelegationResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *RedelegationResponse) GetRedelegation() *Redelegation {
+	if x != nil {
+		return x.Redelegation
+	}
+	return nil
+}
+
+func (x *RedelegationResponse) GetEntries() []*RedelegationEntryResponse {
+	if x != nil {
+		return x.Entries
+	}
+	return nil
+}
+
+// Pool is used for tracking bonded and not-bonded token supply of the bond
+// denomination.
+type Pool struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	NotBondedTokens string `protobuf:"bytes,1,opt,name=not_bonded_tokens,json=notBondedTokens,proto3" json:"not_bonded_tokens,omitempty"`
+	BondedTokens    string `protobuf:"bytes,2,opt,name=bonded_tokens,json=bondedTokens,proto3" json:"bonded_tokens,omitempty"`
+}
+
+func (x *Pool) Reset() {
+	*x = Pool{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Pool) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Pool) ProtoMessage() {}
+
+// Deprecated: Use Pool.ProtoReflect.Descriptor instead.
+func (*Pool) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *Pool) GetNotBondedTokens() string {
+	if x != nil {
+		return x.NotBondedTokens
+	}
+	return ""
+}
+
+func (x *Pool) GetBondedTokens() string {
+	if x != nil {
+		return x.BondedTokens
+	}
+	return ""
+}
+
+// ValidatorUpdates defines an array of abci.ValidatorUpdate objects.
+// TODO: explore moving this to proto/cosmos/base to separate modules from tendermint dependence
+type ValidatorUpdates struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Updates []*abci.ValidatorUpdate `protobuf:"bytes,1,rep,name=updates,proto3" json:"updates,omitempty"`
+}
+
+func (x *ValidatorUpdates) Reset() {
+	*x = ValidatorUpdates{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_staking_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ValidatorUpdates) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ValidatorUpdates) ProtoMessage() {}
+
+// Deprecated: Use ValidatorUpdates.ProtoReflect.Descriptor instead.
+func (*ValidatorUpdates) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *ValidatorUpdates) GetUpdates() []*abci.ValidatorUpdate {
+	if x != nil {
+		return x.Updates
+	}
+	return nil
+}
+
+var File_cosmos_staking_v1beta1_staking_proto protoreflect.FileDescriptor
+
+var file_cosmos_staking_v1beta1_staking_proto_rawDesc = []byte{
+	0x0a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x1a, 0x14,
+	0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a,
+	0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a,
+	0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2f, 0x63, 0x6f, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x11, 0x61, 0x6d, 0x69,
+	0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c,
+	0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73,
+	0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x74, 0x65,
+	0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2f, 0x61, 0x62, 0x63, 0x69, 0x2f, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x93, 0x01, 0x0a, 0x0e, 0x48, 0x69,
+	0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3b, 0x0a, 0x06,
+	0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x74,
+	0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e,
+	0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a,
+	0x01, 0x52, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x44, 0x0a, 0x06, 0x76, 0x61, 0x6c,
+	0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x42, 0x09, 0xc8, 0xde,
+	0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x73, 0x65, 0x74, 0x22,
+	0x96, 0x02, 0x0a, 0x0f, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61,
+	0x74, 0x65, 0x73, 0x12, 0x4a, 0x0a, 0x04, 0x72, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x42, 0x36, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65, 0x67,
+	0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x44, 0x65, 0x63, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x04, 0x72, 0x61, 0x74, 0x65, 0x12,
+	0x51, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x42, 0x36, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65, 0x67,
+	0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x44, 0x65, 0x63, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x52, 0x61,
+	0x74, 0x65, 0x12, 0x5e, 0x0a, 0x0f, 0x6d, 0x61, 0x78, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65,
+	0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x36, 0xc8, 0xde, 0x1f,
+	0x00, 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69,
+	0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x44, 0x65, 0x63,
+	0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x44, 0x65, 0x63, 0xa8, 0xe7,
+	0xb0, 0x2a, 0x01, 0x52, 0x0d, 0x6d, 0x61, 0x78, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x61,
+	0x74, 0x65, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xc1, 0x01, 0x0a, 0x0a, 0x43, 0x6f, 0x6d,
+	0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x61, 0x0a, 0x10, 0x63, 0x6f, 0x6d, 0x6d, 0x69,
+	0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69,
+	0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69,
+	0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x73, 0x42, 0x0d, 0xc8, 0xde, 0x1f, 0x00,
+	0xd0, 0xde, 0x1f, 0x01, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69,
+	0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x4a, 0x0a, 0x0b, 0x75, 0x70,
+	0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x0d, 0xc8, 0xde, 0x1f,
+	0x00, 0x90, 0xdf, 0x1f, 0x01, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x75, 0x70, 0x64, 0x61,
+	0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xa8, 0x01, 0x0a,
+	0x0b, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07,
+	0x6d, 0x6f, 0x6e, 0x69, 0x6b, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d,
+	0x6f, 0x6e, 0x69, 0x6b, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69,
+	0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69,
+	0x74, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x77, 0x65, 0x62, 0x73, 0x69, 0x74, 0x65, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x07, 0x77, 0x65, 0x62, 0x73, 0x69, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x10,
+	0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79,
+	0x43, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69,
+	0x6c, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c,
+	0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x8a, 0x07, 0x0a, 0x09, 0x56, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x43, 0x0a, 0x10, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f,
+	0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42,
+	0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0f, 0x6f, 0x70, 0x65, 0x72, 0x61,
+	0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x59, 0x0a, 0x10, 0x63, 0x6f,
+	0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x42, 0x18, 0xca, 0xb4, 0x2d, 0x14,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, 0x50, 0x75,
+	0x62, 0x4b, 0x65, 0x79, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x50,
+	0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x6a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x6a, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x12, 0x3a, 0x0a,
+	0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76,
+	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x42, 0x6f, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75,
+	0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x43, 0x0a, 0x06, 0x74, 0x6f, 0x6b,
+	0x65, 0x6e, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2b, 0xc8, 0xde, 0x1f, 0x00, 0xda,
+	0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f,
+	0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x06, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x5c,
+	0x0a, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x73, 0x68, 0x61, 0x72,
+	0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x42, 0x31, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde,
+	0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d,
+	0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0xd2, 0xb4, 0x2d,
+	0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x44, 0x65, 0x63, 0x52, 0x0f, 0x64, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x68, 0x61, 0x72, 0x65, 0x73, 0x12, 0x50, 0x0a, 0x0b,
+	0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x23, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69,
+	0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72,
+	0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a,
+	0x01, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x29,
+	0x0a, 0x10, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x68, 0x65, 0x69, 0x67,
+	0x68, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64,
+	0x69, 0x6e, 0x67, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x50, 0x0a, 0x0e, 0x75, 0x6e, 0x62,
+	0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x0d, 0xc8,
+	0xde, 0x1f, 0x00, 0x90, 0xdf, 0x1f, 0x01, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0d, 0x75, 0x6e,
+	0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x4d, 0x0a, 0x0a, 0x63,
+	0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x22, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73,
+	0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a,
+	0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x5b, 0x0a, 0x13, 0x6d, 0x69,
+	0x6e, 0x5f, 0x73, 0x65, 0x6c, 0x66, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2b, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f,
+	0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61,
+	0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x49, 0x6e, 0x74, 0x52, 0x11, 0x6d, 0x69, 0x6e, 0x53, 0x65, 0x6c, 0x66, 0x44, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3c, 0x0a, 0x1b, 0x75, 0x6e, 0x62, 0x6f, 0x6e,
+	0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x6e, 0x5f, 0x68, 0x6f, 0x6c, 0x64, 0x5f, 0x72, 0x65, 0x66,
+	0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x17, 0x75, 0x6e,
+	0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4f, 0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x52, 0x65, 0x66,
+	0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69,
+	0x6e, 0x67, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x04, 0x52, 0x0c, 0x75, 0x6e,
+	0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x49, 0x64, 0x73, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00,
+	0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x46, 0x0a, 0x0c, 0x56, 0x61, 0x6c, 0x41, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x65, 0x73, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65,
+	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, 0xa9, 0x01, 0x0a,
+	0x06, 0x44, 0x56, 0x50, 0x61, 0x69, 0x72, 0x12, 0x45, 0x0a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x64, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x4e,
+	0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x08,
+	0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x4a, 0x0a, 0x07, 0x44, 0x56, 0x50, 0x61,
+	0x69, 0x72, 0x73, 0x12, 0x3f, 0x0a, 0x05, 0x70, 0x61, 0x69, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b,
+	0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x56, 0x50, 0x61,
+	0x69, 0x72, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x05, 0x70,
+	0x61, 0x69, 0x72, 0x73, 0x22, 0x8b, 0x02, 0x0a, 0x0a, 0x44, 0x56, 0x56, 0x54, 0x72, 0x69, 0x70,
+	0x6c, 0x65, 0x74, 0x12, 0x45, 0x0a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72,
+	0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18,
+	0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x55, 0x0a, 0x15, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x73, 0x72, 0x63, 0x5f, 0x61, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x13, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x72, 0x63, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
+	0x73, 0x12, 0x55, 0x0a, 0x15, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x64,
+	0x73, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
+	0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x52, 0x13, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x44, 0x73,
+	0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0,
+	0x1f, 0x00, 0x22, 0x58, 0x0a, 0x0b, 0x44, 0x56, 0x56, 0x54, 0x72, 0x69, 0x70, 0x6c, 0x65, 0x74,
+	0x73, 0x12, 0x49, 0x0a, 0x08, 0x74, 0x72, 0x69, 0x70, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x56, 0x56,
+	0x54, 0x72, 0x69, 0x70, 0x6c, 0x65, 0x74, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0,
+	0x2a, 0x01, 0x52, 0x08, 0x74, 0x72, 0x69, 0x70, 0x6c, 0x65, 0x74, 0x73, 0x22, 0xf8, 0x01, 0x0a,
+	0x0a, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x45, 0x0a, 0x11, 0x64,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x52, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x12, 0x4e, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f,
+	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2,
+	0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
+	0x52, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x12, 0x49, 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x09, 0x42, 0x31, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65,
+	0x67, 0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x44, 0x65, 0x63, 0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x65, 0x73, 0x3a, 0x08, 0x88,
+	0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x8d, 0x02, 0x0a, 0x13, 0x55, 0x6e, 0x62, 0x6f,
+	0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12,
+	0x45, 0x0a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x4e, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x55, 0x0a, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65,
+	0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8,
+	0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3a, 0x08, 0x88,
+	0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x9b, 0x03, 0x0a, 0x18, 0x55, 0x6e, 0x62, 0x6f,
+	0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x63,
+	0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x52, 0x0a,
+	0x0f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
+	0x6d, 0x70, 0x42, 0x0d, 0xc8, 0xde, 0x1f, 0x00, 0x90, 0xdf, 0x1f, 0x01, 0xa8, 0xe7, 0xb0, 0x2a,
+	0x01, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d,
+	0x65, 0x12, 0x54, 0x0a, 0x0f, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x62, 0x61, 0x6c,
+	0x61, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2b, 0xc8, 0xde, 0x1f, 0x00,
+	0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f,
+	0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x0e, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c,
+	0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x45, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e,
+	0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2b, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde,
+	0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d,
+	0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x21,
+	0x0a, 0x0c, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x69, 0x64, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x49,
+	0x64, 0x12, 0x3c, 0x0a, 0x1b, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6f,
+	0x6e, 0x5f, 0x68, 0x6f, 0x6c, 0x64, 0x5f, 0x72, 0x65, 0x66, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x17, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e,
+	0x67, 0x4f, 0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x52, 0x65, 0x66, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x3a,
+	0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x9f, 0x03, 0x0a, 0x11, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x63,
+	0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x12, 0x52, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69,
+	0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x0d, 0xc8, 0xde, 0x1f, 0x00, 0x90,
+	0xdf, 0x1f, 0x01, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65,
+	0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x54, 0x0a, 0x0f, 0x69, 0x6e, 0x69, 0x74,
+	0x69, 0x61, 0x6c, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x09, 0x42, 0x2b, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74,
+	0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x0e,
+	0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x50,
+	0x0a, 0x0a, 0x73, 0x68, 0x61, 0x72, 0x65, 0x73, 0x5f, 0x64, 0x73, 0x74, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x09, 0x42, 0x31, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65,
+	0x67, 0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x44, 0x65, 0x63, 0x52, 0x09, 0x73, 0x68, 0x61, 0x72, 0x65, 0x73, 0x44, 0x73, 0x74,
+	0x12, 0x21, 0x0a, 0x0c, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x69, 0x64,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e,
+	0x67, 0x49, 0x64, 0x12, 0x3c, 0x0a, 0x1b, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67,
+	0x5f, 0x6f, 0x6e, 0x5f, 0x68, 0x6f, 0x6c, 0x64, 0x5f, 0x72, 0x65, 0x66, 0x5f, 0x63, 0x6f, 0x75,
+	0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x17, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64,
+	0x69, 0x6e, 0x67, 0x4f, 0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x52, 0x65, 0x66, 0x43, 0x6f, 0x75, 0x6e,
+	0x74, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xdd, 0x02, 0x0a, 0x0c, 0x52, 0x65, 0x64, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x45, 0x0a, 0x11, 0x64, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x64,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12,
+	0x55, 0x0a, 0x15, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x73, 0x72, 0x63,
+	0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21,
+	0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x52, 0x13, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x72, 0x63, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x55, 0x0a, 0x15, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x5f, 0x64, 0x73, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x13, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x44, 0x73, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x4e, 0x0a,
+	0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29,
+	0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8,
+	0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3a, 0x08, 0x88,
+	0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xa3, 0x04, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61,
+	0x6d, 0x73, 0x12, 0x4f, 0x0a, 0x0e, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f,
+	0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x0d, 0xc8, 0xde, 0x1f, 0x00, 0x98, 0xdf, 0x1f, 0x01, 0xa8,
+	0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0d, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x54,
+	0x69, 0x6d, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x6d, 0x61, 0x78, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0d, 0x6d, 0x61, 0x78,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61,
+	0x78, 0x5f, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52,
+	0x0a, 0x6d, 0x61, 0x78, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x2d, 0x0a, 0x12, 0x68,
+	0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65,
+	0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x11, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69,
+	0x63, 0x61, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6f,
+	0x6e, 0x64, 0x5f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x62, 0x6f, 0x6e, 0x64, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x12, 0x84, 0x01, 0x0a, 0x13, 0x6d, 0x69,
+	0x6e, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74,
+	0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x42, 0x54, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f,
+	0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61,
+	0x74, 0x68, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x44, 0x65, 0x63, 0xf2, 0xde, 0x1f, 0x1a,
+	0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73,
+	0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x22, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x44, 0x65, 0x63, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x11, 0x6d,
+	0x69, 0x6e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65,
+	0x12, 0x84, 0x01, 0x0a, 0x13, 0x6d, 0x61, 0x78, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73,
+	0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x42, 0x54,
+	0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64,
+	0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79,
+	0x44, 0x65, 0x63, 0xf2, 0xde, 0x1f, 0x1a, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x6d, 0x61, 0x78,
+	0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65,
+	0x22, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x44, 0x65, 0x63, 0xa8,
+	0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x11, 0x6d, 0x61, 0x78, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73,
+	0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x3a, 0x24, 0xe8, 0xa0, 0x1f, 0x01, 0x8a, 0xe7, 0xb0,
+	0x2a, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x78, 0x2f, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0xa9, 0x01,
+	0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4d, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde,
+	0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61,
+	0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42,
+	0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61,
+	0x6e, 0x63, 0x65, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xcd, 0x01, 0x0a, 0x19, 0x52, 0x65,
+	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x63, 0x0a, 0x12, 0x72, 0x65, 0x64, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x52, 0x65, 0x64,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x09,
+	0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x11, 0x72, 0x65, 0x64, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x45, 0x0a, 0x07,
+	0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2b, 0xc8,
+	0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b,
+	0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0a,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61,
+	0x6e, 0x63, 0x65, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xc9, 0x01, 0x0a, 0x14, 0x52, 0x65,
+	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x53, 0x0a, 0x0c, 0x72, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09,
+	0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0c, 0x72, 0x65, 0x64, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x56, 0x0a, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69,
+	0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x09, 0xc8, 0xde, 0x1f,
+	0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3a,
+	0x04, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xeb, 0x01, 0x0a, 0x04, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x71,
+	0x0a, 0x11, 0x6e, 0x6f, 0x74, 0x5f, 0x62, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b,
+	0x65, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x45, 0xc8, 0xde, 0x1f, 0x00, 0xda,
+	0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f,
+	0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xea, 0xde, 0x1f, 0x11, 0x6e, 0x6f, 0x74, 0x5f,
+	0x62, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0xd2, 0xb4, 0x2d,
+	0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0xa8, 0xe7, 0xb0, 0x2a, 0x01,
+	0x52, 0x0f, 0x6e, 0x6f, 0x74, 0x42, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
+	0x73, 0x12, 0x66, 0x0a, 0x0d, 0x62, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65,
+	0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x41, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde,
+	0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d,
+	0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xea, 0xde, 0x1f, 0x0d, 0x62, 0x6f, 0x6e, 0x64, 0x65,
+	0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0c, 0x62, 0x6f, 0x6e,
+	0x64, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x3a, 0x08, 0xe8, 0xa0, 0x1f, 0x01, 0xf0,
+	0xa0, 0x1f, 0x01, 0x22, 0x59, 0x0a, 0x10, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x12, 0x45, 0x0a, 0x07, 0x75, 0x70, 0x64, 0x61, 0x74,
+	0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x65, 0x6e, 0x64, 0x65,
+	0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x61, 0x62, 0x63, 0x69, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00,
+	0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x2a, 0xb6,
+	0x01, 0x0a, 0x0a, 0x42, 0x6f, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2c, 0x0a,
+	0x17, 0x42, 0x4f, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53,
+	0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x1a, 0x0f, 0x8a, 0x9d, 0x20, 0x0b,
+	0x55, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x12, 0x26, 0x0a, 0x14, 0x42,
+	0x4f, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x42, 0x4f, 0x4e,
+	0x44, 0x45, 0x44, 0x10, 0x01, 0x1a, 0x0c, 0x8a, 0x9d, 0x20, 0x08, 0x55, 0x6e, 0x62, 0x6f, 0x6e,
+	0x64, 0x65, 0x64, 0x12, 0x28, 0x0a, 0x15, 0x42, 0x4f, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54,
+	0x55, 0x53, 0x5f, 0x55, 0x4e, 0x42, 0x4f, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x1a, 0x0d,
+	0x8a, 0x9d, 0x20, 0x09, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x22, 0x0a,
+	0x12, 0x42, 0x4f, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x42, 0x4f, 0x4e,
+	0x44, 0x45, 0x44, 0x10, 0x03, 0x1a, 0x0a, 0x8a, 0x9d, 0x20, 0x06, 0x42, 0x6f, 0x6e, 0x64, 0x65,
+	0x64, 0x1a, 0x04, 0x88, 0xa3, 0x1e, 0x00, 0x2a, 0x5d, 0x0a, 0x0a, 0x49, 0x6e, 0x66, 0x72, 0x61,
+	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x16, 0x49, 0x4e, 0x46, 0x52, 0x41, 0x43, 0x54,
+	0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10,
+	0x00, 0x12, 0x1a, 0x0a, 0x16, 0x49, 0x4e, 0x46, 0x52, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f,
+	0x44, 0x4f, 0x55, 0x42, 0x4c, 0x45, 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x10, 0x01, 0x12, 0x17, 0x0a,
+	0x13, 0x49, 0x4e, 0x46, 0x52, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x4f, 0x57, 0x4e,
+	0x54, 0x49, 0x4d, 0x45, 0x10, 0x02, 0x42, 0xdc, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x42, 0x0c, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x36, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b,
+	0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03,
+	0x43, 0x53, 0x58, 0xaa, 0x02, 0x16, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x53, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, 0x02, 0x16, 0x43,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, 0x22, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47,
+	0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x18, 0x43, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cosmos_staking_v1beta1_staking_proto_rawDescOnce sync.Once
+	file_cosmos_staking_v1beta1_staking_proto_rawDescData = file_cosmos_staking_v1beta1_staking_proto_rawDesc
+)
+
+func file_cosmos_staking_v1beta1_staking_proto_rawDescGZIP() []byte {
+	file_cosmos_staking_v1beta1_staking_proto_rawDescOnce.Do(func() {
+		file_cosmos_staking_v1beta1_staking_proto_rawDescData = protoimpl.X.CompressGZIP(file_cosmos_staking_v1beta1_staking_proto_rawDescData)
+	})
+	return file_cosmos_staking_v1beta1_staking_proto_rawDescData
+}
+
+var file_cosmos_staking_v1beta1_staking_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
+var file_cosmos_staking_v1beta1_staking_proto_msgTypes = make([]protoimpl.MessageInfo, 21)
+var file_cosmos_staking_v1beta1_staking_proto_goTypes = []interface{}{
+	(BondStatus)(0),                   // 0: cosmos.staking.v1beta1.BondStatus
+	(Infraction)(0),                   // 1: cosmos.staking.v1beta1.Infraction
+	(*HistoricalInfo)(nil),            // 2: cosmos.staking.v1beta1.HistoricalInfo
+	(*CommissionRates)(nil),           // 3: cosmos.staking.v1beta1.CommissionRates
+	(*Commission)(nil),                // 4: cosmos.staking.v1beta1.Commission
+	(*Description)(nil),               // 5: cosmos.staking.v1beta1.Description
+	(*Validator)(nil),                 // 6: cosmos.staking.v1beta1.Validator
+	(*ValAddresses)(nil),              // 7: cosmos.staking.v1beta1.ValAddresses
+	(*DVPair)(nil),                    // 8: cosmos.staking.v1beta1.DVPair
+	(*DVPairs)(nil),                   // 9: cosmos.staking.v1beta1.DVPairs
+	(*DVVTriplet)(nil),                // 10: cosmos.staking.v1beta1.DVVTriplet
+	(*DVVTriplets)(nil),               // 11: cosmos.staking.v1beta1.DVVTriplets
+	(*Delegation)(nil),                // 12: cosmos.staking.v1beta1.Delegation
+	(*UnbondingDelegation)(nil),       // 13: cosmos.staking.v1beta1.UnbondingDelegation
+	(*UnbondingDelegationEntry)(nil),  // 14: cosmos.staking.v1beta1.UnbondingDelegationEntry
+	(*RedelegationEntry)(nil),         // 15: cosmos.staking.v1beta1.RedelegationEntry
+	(*Redelegation)(nil),              // 16: cosmos.staking.v1beta1.Redelegation
+	(*Params)(nil),                    // 17: cosmos.staking.v1beta1.Params
+	(*DelegationResponse)(nil),        // 18: cosmos.staking.v1beta1.DelegationResponse
+	(*RedelegationEntryResponse)(nil), // 19: cosmos.staking.v1beta1.RedelegationEntryResponse
+	(*RedelegationResponse)(nil),      // 20: cosmos.staking.v1beta1.RedelegationResponse
+	(*Pool)(nil),                      // 21: cosmos.staking.v1beta1.Pool
+	(*ValidatorUpdates)(nil),          // 22: cosmos.staking.v1beta1.ValidatorUpdates
+	(*types.Header)(nil),              // 23: tendermint.types.Header
+	(*timestamppb.Timestamp)(nil),     // 24: google.protobuf.Timestamp
+	(*anypb.Any)(nil),                 // 25: google.protobuf.Any
+	(*durationpb.Duration)(nil),       // 26: google.protobuf.Duration
+	(*v1beta1.Coin)(nil),              // 27: cosmos.base.v1beta1.Coin
+	(*abci.ValidatorUpdate)(nil),      // 28: tendermint.abci.ValidatorUpdate
+}
+var file_cosmos_staking_v1beta1_staking_proto_depIdxs = []int32{
+	23, // 0: cosmos.staking.v1beta1.HistoricalInfo.header:type_name -> tendermint.types.Header
+	6,  // 1: cosmos.staking.v1beta1.HistoricalInfo.valset:type_name -> cosmos.staking.v1beta1.Validator
+	3,  // 2: cosmos.staking.v1beta1.Commission.commission_rates:type_name -> cosmos.staking.v1beta1.CommissionRates
+	24, // 3: cosmos.staking.v1beta1.Commission.update_time:type_name -> google.protobuf.Timestamp
+	25, // 4: cosmos.staking.v1beta1.Validator.consensus_pubkey:type_name -> google.protobuf.Any
+	0,  // 5: cosmos.staking.v1beta1.Validator.status:type_name -> cosmos.staking.v1beta1.BondStatus
+	5,  // 6: cosmos.staking.v1beta1.Validator.description:type_name -> cosmos.staking.v1beta1.Description
+	24, // 7: cosmos.staking.v1beta1.Validator.unbonding_time:type_name -> google.protobuf.Timestamp
+	4,  // 8: cosmos.staking.v1beta1.Validator.commission:type_name -> cosmos.staking.v1beta1.Commission
+	8,  // 9: cosmos.staking.v1beta1.DVPairs.pairs:type_name -> cosmos.staking.v1beta1.DVPair
+	10, // 10: cosmos.staking.v1beta1.DVVTriplets.triplets:type_name -> cosmos.staking.v1beta1.DVVTriplet
+	14, // 11: cosmos.staking.v1beta1.UnbondingDelegation.entries:type_name -> cosmos.staking.v1beta1.UnbondingDelegationEntry
+	24, // 12: cosmos.staking.v1beta1.UnbondingDelegationEntry.completion_time:type_name -> google.protobuf.Timestamp
+	24, // 13: cosmos.staking.v1beta1.RedelegationEntry.completion_time:type_name -> google.protobuf.Timestamp
+	15, // 14: cosmos.staking.v1beta1.Redelegation.entries:type_name -> cosmos.staking.v1beta1.RedelegationEntry
+	26, // 15: cosmos.staking.v1beta1.Params.unbonding_time:type_name -> google.protobuf.Duration
+	12, // 16: cosmos.staking.v1beta1.DelegationResponse.delegation:type_name -> cosmos.staking.v1beta1.Delegation
+	27, // 17: cosmos.staking.v1beta1.DelegationResponse.balance:type_name -> cosmos.base.v1beta1.Coin
+	15, // 18: cosmos.staking.v1beta1.RedelegationEntryResponse.redelegation_entry:type_name -> cosmos.staking.v1beta1.RedelegationEntry
+	16, // 19: cosmos.staking.v1beta1.RedelegationResponse.redelegation:type_name -> cosmos.staking.v1beta1.Redelegation
+	19, // 20: cosmos.staking.v1beta1.RedelegationResponse.entries:type_name -> cosmos.staking.v1beta1.RedelegationEntryResponse
+	28, // 21: cosmos.staking.v1beta1.ValidatorUpdates.updates:type_name -> tendermint.abci.ValidatorUpdate
+	22, // [22:22] is the sub-list for method output_type
+	22, // [22:22] is the sub-list for method input_type
+	22, // [22:22] is the sub-list for extension type_name
+	22, // [22:22] is the sub-list for extension extendee
+	0,  // [0:22] is the sub-list for field type_name
+}
+
+func init() { file_cosmos_staking_v1beta1_staking_proto_init() }
+func file_cosmos_staking_v1beta1_staking_proto_init() {
+	if File_cosmos_staking_v1beta1_staking_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*HistoricalInfo); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CommissionRates); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Commission); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Description); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Validator); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ValAddresses); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DVPair); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DVPairs); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DVVTriplet); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DVVTriplets); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Delegation); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*UnbondingDelegation); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*UnbondingDelegationEntry); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RedelegationEntry); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Redelegation); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Params); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DelegationResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RedelegationEntryResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RedelegationResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Pool); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_staking_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ValidatorUpdates); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cosmos_staking_v1beta1_staking_proto_rawDesc,
+			NumEnums:      2,
+			NumMessages:   21,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_cosmos_staking_v1beta1_staking_proto_goTypes,
+		DependencyIndexes: file_cosmos_staking_v1beta1_staking_proto_depIdxs,
+		EnumInfos:         file_cosmos_staking_v1beta1_staking_proto_enumTypes,
+		MessageInfos:      file_cosmos_staking_v1beta1_staking_proto_msgTypes,
+	}.Build()
+	File_cosmos_staking_v1beta1_staking_proto = out.File
+	file_cosmos_staking_v1beta1_staking_proto_rawDesc = nil
+	file_cosmos_staking_v1beta1_staking_proto_goTypes = nil
+	file_cosmos_staking_v1beta1_staking_proto_depIdxs = nil
+}
diff --git a/atomone-api/cosmos/staking/v1beta1/tx.pulsar.go b/atomone-api/cosmos/staking/v1beta1/tx.pulsar.go
new file mode 100644
index 000000000000..37cae89fdee7
--- /dev/null
+++ b/atomone-api/cosmos/staking/v1beta1/tx.pulsar.go
@@ -0,0 +1,8317 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package stakingv1beta1
+
+import (
+	_ "cosmossdk.io/api/amino"
+	v1beta1 "cosmossdk.io/api/cosmos/base/v1beta1"
+	_ "cosmossdk.io/api/cosmos/msg/v1"
+	fmt "fmt"
+	_ "github.com/cosmos/cosmos-proto"
+	runtime "github.com/cosmos/cosmos-proto/runtime"
+	_ "github.com/cosmos/gogoproto/gogoproto"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	anypb "google.golang.org/protobuf/types/known/anypb"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	io "io"
+	reflect "reflect"
+	sync "sync"
+)
+
+var (
+	md_MsgCreateValidator                     protoreflect.MessageDescriptor
+	fd_MsgCreateValidator_description         protoreflect.FieldDescriptor
+	fd_MsgCreateValidator_commission          protoreflect.FieldDescriptor
+	fd_MsgCreateValidator_min_self_delegation protoreflect.FieldDescriptor
+	fd_MsgCreateValidator_delegator_address   protoreflect.FieldDescriptor
+	fd_MsgCreateValidator_validator_address   protoreflect.FieldDescriptor
+	fd_MsgCreateValidator_pubkey              protoreflect.FieldDescriptor
+	fd_MsgCreateValidator_value               protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgCreateValidator = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgCreateValidator")
+	fd_MsgCreateValidator_description = md_MsgCreateValidator.Fields().ByName("description")
+	fd_MsgCreateValidator_commission = md_MsgCreateValidator.Fields().ByName("commission")
+	fd_MsgCreateValidator_min_self_delegation = md_MsgCreateValidator.Fields().ByName("min_self_delegation")
+	fd_MsgCreateValidator_delegator_address = md_MsgCreateValidator.Fields().ByName("delegator_address")
+	fd_MsgCreateValidator_validator_address = md_MsgCreateValidator.Fields().ByName("validator_address")
+	fd_MsgCreateValidator_pubkey = md_MsgCreateValidator.Fields().ByName("pubkey")
+	fd_MsgCreateValidator_value = md_MsgCreateValidator.Fields().ByName("value")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgCreateValidator)(nil)
+
+type fastReflection_MsgCreateValidator MsgCreateValidator
+
+func (x *MsgCreateValidator) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCreateValidator)(x)
+}
+
+func (x *MsgCreateValidator) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgCreateValidator_messageType fastReflection_MsgCreateValidator_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCreateValidator_messageType{}
+
+type fastReflection_MsgCreateValidator_messageType struct{}
+
+func (x fastReflection_MsgCreateValidator_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCreateValidator)(nil)
+}
+func (x fastReflection_MsgCreateValidator_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCreateValidator)
+}
+func (x fastReflection_MsgCreateValidator_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreateValidator
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgCreateValidator) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreateValidator
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgCreateValidator) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCreateValidator_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgCreateValidator) New() protoreflect.Message {
+	return new(fastReflection_MsgCreateValidator)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgCreateValidator) Interface() protoreflect.ProtoMessage {
+	return (*MsgCreateValidator)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgCreateValidator) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Description != nil {
+		value := protoreflect.ValueOfMessage(x.Description.ProtoReflect())
+		if !f(fd_MsgCreateValidator_description, value) {
+			return
+		}
+	}
+	if x.Commission != nil {
+		value := protoreflect.ValueOfMessage(x.Commission.ProtoReflect())
+		if !f(fd_MsgCreateValidator_commission, value) {
+			return
+		}
+	}
+	if x.MinSelfDelegation != "" {
+		value := protoreflect.ValueOfString(x.MinSelfDelegation)
+		if !f(fd_MsgCreateValidator_min_self_delegation, value) {
+			return
+		}
+	}
+	if x.DelegatorAddress != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddress)
+		if !f(fd_MsgCreateValidator_delegator_address, value) {
+			return
+		}
+	}
+	if x.ValidatorAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddress)
+		if !f(fd_MsgCreateValidator_validator_address, value) {
+			return
+		}
+	}
+	if x.Pubkey != nil {
+		value := protoreflect.ValueOfMessage(x.Pubkey.ProtoReflect())
+		if !f(fd_MsgCreateValidator_pubkey, value) {
+			return
+		}
+	}
+	if x.Value != nil {
+		value := protoreflect.ValueOfMessage(x.Value.ProtoReflect())
+		if !f(fd_MsgCreateValidator_value, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgCreateValidator) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgCreateValidator.description":
+		return x.Description != nil
+	case "cosmos.staking.v1beta1.MsgCreateValidator.commission":
+		return x.Commission != nil
+	case "cosmos.staking.v1beta1.MsgCreateValidator.min_self_delegation":
+		return x.MinSelfDelegation != ""
+	case "cosmos.staking.v1beta1.MsgCreateValidator.delegator_address":
+		return x.DelegatorAddress != ""
+	case "cosmos.staking.v1beta1.MsgCreateValidator.validator_address":
+		return x.ValidatorAddress != ""
+	case "cosmos.staking.v1beta1.MsgCreateValidator.pubkey":
+		return x.Pubkey != nil
+	case "cosmos.staking.v1beta1.MsgCreateValidator.value":
+		return x.Value != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidator does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCreateValidator) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgCreateValidator.description":
+		x.Description = nil
+	case "cosmos.staking.v1beta1.MsgCreateValidator.commission":
+		x.Commission = nil
+	case "cosmos.staking.v1beta1.MsgCreateValidator.min_self_delegation":
+		x.MinSelfDelegation = ""
+	case "cosmos.staking.v1beta1.MsgCreateValidator.delegator_address":
+		x.DelegatorAddress = ""
+	case "cosmos.staking.v1beta1.MsgCreateValidator.validator_address":
+		x.ValidatorAddress = ""
+	case "cosmos.staking.v1beta1.MsgCreateValidator.pubkey":
+		x.Pubkey = nil
+	case "cosmos.staking.v1beta1.MsgCreateValidator.value":
+		x.Value = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidator does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgCreateValidator) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.MsgCreateValidator.description":
+		value := x.Description
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCreateValidator.commission":
+		value := x.Commission
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCreateValidator.min_self_delegation":
+		value := x.MinSelfDelegation
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgCreateValidator.delegator_address":
+		value := x.DelegatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgCreateValidator.validator_address":
+		value := x.ValidatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgCreateValidator.pubkey":
+		value := x.Pubkey
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCreateValidator.value":
+		value := x.Value
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidator does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCreateValidator) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgCreateValidator.description":
+		x.Description = value.Message().Interface().(*Description)
+	case "cosmos.staking.v1beta1.MsgCreateValidator.commission":
+		x.Commission = value.Message().Interface().(*CommissionRates)
+	case "cosmos.staking.v1beta1.MsgCreateValidator.min_self_delegation":
+		x.MinSelfDelegation = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgCreateValidator.delegator_address":
+		x.DelegatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgCreateValidator.validator_address":
+		x.ValidatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgCreateValidator.pubkey":
+		x.Pubkey = value.Message().Interface().(*anypb.Any)
+	case "cosmos.staking.v1beta1.MsgCreateValidator.value":
+		x.Value = value.Message().Interface().(*v1beta1.Coin)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidator does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCreateValidator) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgCreateValidator.description":
+		if x.Description == nil {
+			x.Description = new(Description)
+		}
+		return protoreflect.ValueOfMessage(x.Description.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCreateValidator.commission":
+		if x.Commission == nil {
+			x.Commission = new(CommissionRates)
+		}
+		return protoreflect.ValueOfMessage(x.Commission.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCreateValidator.pubkey":
+		if x.Pubkey == nil {
+			x.Pubkey = new(anypb.Any)
+		}
+		return protoreflect.ValueOfMessage(x.Pubkey.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCreateValidator.value":
+		if x.Value == nil {
+			x.Value = new(v1beta1.Coin)
+		}
+		return protoreflect.ValueOfMessage(x.Value.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCreateValidator.min_self_delegation":
+		panic(fmt.Errorf("field min_self_delegation of message cosmos.staking.v1beta1.MsgCreateValidator is not mutable"))
+	case "cosmos.staking.v1beta1.MsgCreateValidator.delegator_address":
+		panic(fmt.Errorf("field delegator_address of message cosmos.staking.v1beta1.MsgCreateValidator is not mutable"))
+	case "cosmos.staking.v1beta1.MsgCreateValidator.validator_address":
+		panic(fmt.Errorf("field validator_address of message cosmos.staking.v1beta1.MsgCreateValidator is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidator does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgCreateValidator) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgCreateValidator.description":
+		m := new(Description)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCreateValidator.commission":
+		m := new(CommissionRates)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCreateValidator.min_self_delegation":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgCreateValidator.delegator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgCreateValidator.validator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgCreateValidator.pubkey":
+		m := new(anypb.Any)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCreateValidator.value":
+		m := new(v1beta1.Coin)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidator does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgCreateValidator) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgCreateValidator", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgCreateValidator) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCreateValidator) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgCreateValidator) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgCreateValidator) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgCreateValidator)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Description != nil {
+			l = options.Size(x.Description)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Commission != nil {
+			l = options.Size(x.Commission)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.MinSelfDelegation)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.DelegatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Pubkey != nil {
+			l = options.Size(x.Pubkey)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Value != nil {
+			l = options.Size(x.Value)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgCreateValidator)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Value != nil {
+			encoded, err := options.Marshal(x.Value)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x3a
+		}
+		if x.Pubkey != nil {
+			encoded, err := options.Marshal(x.Pubkey)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x32
+		}
+		if len(x.ValidatorAddress) > 0 {
+			i -= len(x.ValidatorAddress)
+			copy(dAtA[i:], x.ValidatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddress)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if len(x.DelegatorAddress) > 0 {
+			i -= len(x.DelegatorAddress)
+			copy(dAtA[i:], x.DelegatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddress)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.MinSelfDelegation) > 0 {
+			i -= len(x.MinSelfDelegation)
+			copy(dAtA[i:], x.MinSelfDelegation)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MinSelfDelegation)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.Commission != nil {
+			encoded, err := options.Marshal(x.Commission)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.Description != nil {
+			encoded, err := options.Marshal(x.Description)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgCreateValidator)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateValidator: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateValidator: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Description == nil {
+					x.Description = &Description{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Description); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Commission", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Commission == nil {
+					x.Commission = &CommissionRates{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Commission); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MinSelfDelegation", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.MinSelfDelegation = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 6:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pubkey", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pubkey == nil {
+					x.Pubkey = &anypb.Any{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pubkey); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 7:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Value == nil {
+					x.Value = &v1beta1.Coin{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Value); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgCreateValidatorResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgCreateValidatorResponse = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgCreateValidatorResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgCreateValidatorResponse)(nil)
+
+type fastReflection_MsgCreateValidatorResponse MsgCreateValidatorResponse
+
+func (x *MsgCreateValidatorResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCreateValidatorResponse)(x)
+}
+
+func (x *MsgCreateValidatorResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgCreateValidatorResponse_messageType fastReflection_MsgCreateValidatorResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCreateValidatorResponse_messageType{}
+
+type fastReflection_MsgCreateValidatorResponse_messageType struct{}
+
+func (x fastReflection_MsgCreateValidatorResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCreateValidatorResponse)(nil)
+}
+func (x fastReflection_MsgCreateValidatorResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCreateValidatorResponse)
+}
+func (x fastReflection_MsgCreateValidatorResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreateValidatorResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgCreateValidatorResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreateValidatorResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgCreateValidatorResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCreateValidatorResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgCreateValidatorResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgCreateValidatorResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgCreateValidatorResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgCreateValidatorResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgCreateValidatorResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgCreateValidatorResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCreateValidatorResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgCreateValidatorResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidatorResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCreateValidatorResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCreateValidatorResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgCreateValidatorResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCreateValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCreateValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgCreateValidatorResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgCreateValidatorResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgCreateValidatorResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCreateValidatorResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgCreateValidatorResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgCreateValidatorResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgCreateValidatorResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgCreateValidatorResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgCreateValidatorResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateValidatorResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgEditValidator                     protoreflect.MessageDescriptor
+	fd_MsgEditValidator_description         protoreflect.FieldDescriptor
+	fd_MsgEditValidator_validator_address   protoreflect.FieldDescriptor
+	fd_MsgEditValidator_commission_rate     protoreflect.FieldDescriptor
+	fd_MsgEditValidator_min_self_delegation protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgEditValidator = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgEditValidator")
+	fd_MsgEditValidator_description = md_MsgEditValidator.Fields().ByName("description")
+	fd_MsgEditValidator_validator_address = md_MsgEditValidator.Fields().ByName("validator_address")
+	fd_MsgEditValidator_commission_rate = md_MsgEditValidator.Fields().ByName("commission_rate")
+	fd_MsgEditValidator_min_self_delegation = md_MsgEditValidator.Fields().ByName("min_self_delegation")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgEditValidator)(nil)
+
+type fastReflection_MsgEditValidator MsgEditValidator
+
+func (x *MsgEditValidator) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgEditValidator)(x)
+}
+
+func (x *MsgEditValidator) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgEditValidator_messageType fastReflection_MsgEditValidator_messageType
+var _ protoreflect.MessageType = fastReflection_MsgEditValidator_messageType{}
+
+type fastReflection_MsgEditValidator_messageType struct{}
+
+func (x fastReflection_MsgEditValidator_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgEditValidator)(nil)
+}
+func (x fastReflection_MsgEditValidator_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgEditValidator)
+}
+func (x fastReflection_MsgEditValidator_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgEditValidator
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgEditValidator) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgEditValidator
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgEditValidator) Type() protoreflect.MessageType {
+	return _fastReflection_MsgEditValidator_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgEditValidator) New() protoreflect.Message {
+	return new(fastReflection_MsgEditValidator)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgEditValidator) Interface() protoreflect.ProtoMessage {
+	return (*MsgEditValidator)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgEditValidator) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Description != nil {
+		value := protoreflect.ValueOfMessage(x.Description.ProtoReflect())
+		if !f(fd_MsgEditValidator_description, value) {
+			return
+		}
+	}
+	if x.ValidatorAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddress)
+		if !f(fd_MsgEditValidator_validator_address, value) {
+			return
+		}
+	}
+	if x.CommissionRate != "" {
+		value := protoreflect.ValueOfString(x.CommissionRate)
+		if !f(fd_MsgEditValidator_commission_rate, value) {
+			return
+		}
+	}
+	if x.MinSelfDelegation != "" {
+		value := protoreflect.ValueOfString(x.MinSelfDelegation)
+		if !f(fd_MsgEditValidator_min_self_delegation, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgEditValidator) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgEditValidator.description":
+		return x.Description != nil
+	case "cosmos.staking.v1beta1.MsgEditValidator.validator_address":
+		return x.ValidatorAddress != ""
+	case "cosmos.staking.v1beta1.MsgEditValidator.commission_rate":
+		return x.CommissionRate != ""
+	case "cosmos.staking.v1beta1.MsgEditValidator.min_self_delegation":
+		return x.MinSelfDelegation != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidator does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgEditValidator) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgEditValidator.description":
+		x.Description = nil
+	case "cosmos.staking.v1beta1.MsgEditValidator.validator_address":
+		x.ValidatorAddress = ""
+	case "cosmos.staking.v1beta1.MsgEditValidator.commission_rate":
+		x.CommissionRate = ""
+	case "cosmos.staking.v1beta1.MsgEditValidator.min_self_delegation":
+		x.MinSelfDelegation = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidator does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgEditValidator) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.MsgEditValidator.description":
+		value := x.Description
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgEditValidator.validator_address":
+		value := x.ValidatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgEditValidator.commission_rate":
+		value := x.CommissionRate
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgEditValidator.min_self_delegation":
+		value := x.MinSelfDelegation
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidator does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgEditValidator) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgEditValidator.description":
+		x.Description = value.Message().Interface().(*Description)
+	case "cosmos.staking.v1beta1.MsgEditValidator.validator_address":
+		x.ValidatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgEditValidator.commission_rate":
+		x.CommissionRate = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgEditValidator.min_self_delegation":
+		x.MinSelfDelegation = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidator does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgEditValidator) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgEditValidator.description":
+		if x.Description == nil {
+			x.Description = new(Description)
+		}
+		return protoreflect.ValueOfMessage(x.Description.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgEditValidator.validator_address":
+		panic(fmt.Errorf("field validator_address of message cosmos.staking.v1beta1.MsgEditValidator is not mutable"))
+	case "cosmos.staking.v1beta1.MsgEditValidator.commission_rate":
+		panic(fmt.Errorf("field commission_rate of message cosmos.staking.v1beta1.MsgEditValidator is not mutable"))
+	case "cosmos.staking.v1beta1.MsgEditValidator.min_self_delegation":
+		panic(fmt.Errorf("field min_self_delegation of message cosmos.staking.v1beta1.MsgEditValidator is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidator does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgEditValidator) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgEditValidator.description":
+		m := new(Description)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgEditValidator.validator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgEditValidator.commission_rate":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgEditValidator.min_self_delegation":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidator"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidator does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgEditValidator) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgEditValidator", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgEditValidator) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgEditValidator) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgEditValidator) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgEditValidator) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgEditValidator)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Description != nil {
+			l = options.Size(x.Description)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.CommissionRate)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.MinSelfDelegation)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgEditValidator)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.MinSelfDelegation) > 0 {
+			i -= len(x.MinSelfDelegation)
+			copy(dAtA[i:], x.MinSelfDelegation)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MinSelfDelegation)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.CommissionRate) > 0 {
+			i -= len(x.CommissionRate)
+			copy(dAtA[i:], x.CommissionRate)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.CommissionRate)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.ValidatorAddress) > 0 {
+			i -= len(x.ValidatorAddress)
+			copy(dAtA[i:], x.ValidatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.Description != nil {
+			encoded, err := options.Marshal(x.Description)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgEditValidator)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgEditValidator: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgEditValidator: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Description == nil {
+					x.Description = &Description{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Description); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CommissionRate", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.CommissionRate = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MinSelfDelegation", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.MinSelfDelegation = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgEditValidatorResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgEditValidatorResponse = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgEditValidatorResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgEditValidatorResponse)(nil)
+
+type fastReflection_MsgEditValidatorResponse MsgEditValidatorResponse
+
+func (x *MsgEditValidatorResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgEditValidatorResponse)(x)
+}
+
+func (x *MsgEditValidatorResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgEditValidatorResponse_messageType fastReflection_MsgEditValidatorResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgEditValidatorResponse_messageType{}
+
+type fastReflection_MsgEditValidatorResponse_messageType struct{}
+
+func (x fastReflection_MsgEditValidatorResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgEditValidatorResponse)(nil)
+}
+func (x fastReflection_MsgEditValidatorResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgEditValidatorResponse)
+}
+func (x fastReflection_MsgEditValidatorResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgEditValidatorResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgEditValidatorResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgEditValidatorResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgEditValidatorResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgEditValidatorResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgEditValidatorResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgEditValidatorResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgEditValidatorResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgEditValidatorResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgEditValidatorResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgEditValidatorResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgEditValidatorResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgEditValidatorResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidatorResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgEditValidatorResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgEditValidatorResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgEditValidatorResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgEditValidatorResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgEditValidatorResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgEditValidatorResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgEditValidatorResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgEditValidatorResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgEditValidatorResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgEditValidatorResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgEditValidatorResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgEditValidatorResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgEditValidatorResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgEditValidatorResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgEditValidatorResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgEditValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgDelegate                   protoreflect.MessageDescriptor
+	fd_MsgDelegate_delegator_address protoreflect.FieldDescriptor
+	fd_MsgDelegate_validator_address protoreflect.FieldDescriptor
+	fd_MsgDelegate_amount            protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgDelegate = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgDelegate")
+	fd_MsgDelegate_delegator_address = md_MsgDelegate.Fields().ByName("delegator_address")
+	fd_MsgDelegate_validator_address = md_MsgDelegate.Fields().ByName("validator_address")
+	fd_MsgDelegate_amount = md_MsgDelegate.Fields().ByName("amount")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgDelegate)(nil)
+
+type fastReflection_MsgDelegate MsgDelegate
+
+func (x *MsgDelegate) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgDelegate)(x)
+}
+
+func (x *MsgDelegate) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgDelegate_messageType fastReflection_MsgDelegate_messageType
+var _ protoreflect.MessageType = fastReflection_MsgDelegate_messageType{}
+
+type fastReflection_MsgDelegate_messageType struct{}
+
+func (x fastReflection_MsgDelegate_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgDelegate)(nil)
+}
+func (x fastReflection_MsgDelegate_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgDelegate)
+}
+func (x fastReflection_MsgDelegate_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgDelegate
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgDelegate) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgDelegate
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgDelegate) Type() protoreflect.MessageType {
+	return _fastReflection_MsgDelegate_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgDelegate) New() protoreflect.Message {
+	return new(fastReflection_MsgDelegate)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgDelegate) Interface() protoreflect.ProtoMessage {
+	return (*MsgDelegate)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgDelegate) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddress != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddress)
+		if !f(fd_MsgDelegate_delegator_address, value) {
+			return
+		}
+	}
+	if x.ValidatorAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddress)
+		if !f(fd_MsgDelegate_validator_address, value) {
+			return
+		}
+	}
+	if x.Amount != nil {
+		value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+		if !f(fd_MsgDelegate_amount, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgDelegate) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgDelegate.delegator_address":
+		return x.DelegatorAddress != ""
+	case "cosmos.staking.v1beta1.MsgDelegate.validator_address":
+		return x.ValidatorAddress != ""
+	case "cosmos.staking.v1beta1.MsgDelegate.amount":
+		return x.Amount != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgDelegate) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgDelegate.delegator_address":
+		x.DelegatorAddress = ""
+	case "cosmos.staking.v1beta1.MsgDelegate.validator_address":
+		x.ValidatorAddress = ""
+	case "cosmos.staking.v1beta1.MsgDelegate.amount":
+		x.Amount = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgDelegate) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.MsgDelegate.delegator_address":
+		value := x.DelegatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgDelegate.validator_address":
+		value := x.ValidatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgDelegate.amount":
+		value := x.Amount
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegate does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgDelegate) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgDelegate.delegator_address":
+		x.DelegatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgDelegate.validator_address":
+		x.ValidatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgDelegate.amount":
+		x.Amount = value.Message().Interface().(*v1beta1.Coin)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgDelegate) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgDelegate.amount":
+		if x.Amount == nil {
+			x.Amount = new(v1beta1.Coin)
+		}
+		return protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgDelegate.delegator_address":
+		panic(fmt.Errorf("field delegator_address of message cosmos.staking.v1beta1.MsgDelegate is not mutable"))
+	case "cosmos.staking.v1beta1.MsgDelegate.validator_address":
+		panic(fmt.Errorf("field validator_address of message cosmos.staking.v1beta1.MsgDelegate is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgDelegate) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgDelegate.delegator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgDelegate.validator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgDelegate.amount":
+		m := new(v1beta1.Coin)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgDelegate) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgDelegate", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgDelegate) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgDelegate) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgDelegate) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgDelegate) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgDelegate)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Amount != nil {
+			l = options.Size(x.Amount)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgDelegate)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Amount != nil {
+			encoded, err := options.Marshal(x.Amount)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.ValidatorAddress) > 0 {
+			i -= len(x.ValidatorAddress)
+			copy(dAtA[i:], x.ValidatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddress) > 0 {
+			i -= len(x.DelegatorAddress)
+			copy(dAtA[i:], x.DelegatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddress)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgDelegate)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDelegate: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDelegate: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Amount == nil {
+					x.Amount = &v1beta1.Coin{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgDelegateResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgDelegateResponse = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgDelegateResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgDelegateResponse)(nil)
+
+type fastReflection_MsgDelegateResponse MsgDelegateResponse
+
+func (x *MsgDelegateResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgDelegateResponse)(x)
+}
+
+func (x *MsgDelegateResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgDelegateResponse_messageType fastReflection_MsgDelegateResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgDelegateResponse_messageType{}
+
+type fastReflection_MsgDelegateResponse_messageType struct{}
+
+func (x fastReflection_MsgDelegateResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgDelegateResponse)(nil)
+}
+func (x fastReflection_MsgDelegateResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgDelegateResponse)
+}
+func (x fastReflection_MsgDelegateResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgDelegateResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgDelegateResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgDelegateResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgDelegateResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgDelegateResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgDelegateResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgDelegateResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgDelegateResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgDelegateResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgDelegateResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgDelegateResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgDelegateResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgDelegateResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegateResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgDelegateResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgDelegateResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgDelegateResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgDelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgDelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgDelegateResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgDelegateResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgDelegateResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgDelegateResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgDelegateResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgDelegateResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgDelegateResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgDelegateResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgDelegateResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDelegateResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDelegateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgBeginRedelegate                       protoreflect.MessageDescriptor
+	fd_MsgBeginRedelegate_delegator_address     protoreflect.FieldDescriptor
+	fd_MsgBeginRedelegate_validator_src_address protoreflect.FieldDescriptor
+	fd_MsgBeginRedelegate_validator_dst_address protoreflect.FieldDescriptor
+	fd_MsgBeginRedelegate_amount                protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgBeginRedelegate = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgBeginRedelegate")
+	fd_MsgBeginRedelegate_delegator_address = md_MsgBeginRedelegate.Fields().ByName("delegator_address")
+	fd_MsgBeginRedelegate_validator_src_address = md_MsgBeginRedelegate.Fields().ByName("validator_src_address")
+	fd_MsgBeginRedelegate_validator_dst_address = md_MsgBeginRedelegate.Fields().ByName("validator_dst_address")
+	fd_MsgBeginRedelegate_amount = md_MsgBeginRedelegate.Fields().ByName("amount")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgBeginRedelegate)(nil)
+
+type fastReflection_MsgBeginRedelegate MsgBeginRedelegate
+
+func (x *MsgBeginRedelegate) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgBeginRedelegate)(x)
+}
+
+func (x *MsgBeginRedelegate) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgBeginRedelegate_messageType fastReflection_MsgBeginRedelegate_messageType
+var _ protoreflect.MessageType = fastReflection_MsgBeginRedelegate_messageType{}
+
+type fastReflection_MsgBeginRedelegate_messageType struct{}
+
+func (x fastReflection_MsgBeginRedelegate_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgBeginRedelegate)(nil)
+}
+func (x fastReflection_MsgBeginRedelegate_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgBeginRedelegate)
+}
+func (x fastReflection_MsgBeginRedelegate_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgBeginRedelegate
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgBeginRedelegate) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgBeginRedelegate
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgBeginRedelegate) Type() protoreflect.MessageType {
+	return _fastReflection_MsgBeginRedelegate_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgBeginRedelegate) New() protoreflect.Message {
+	return new(fastReflection_MsgBeginRedelegate)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgBeginRedelegate) Interface() protoreflect.ProtoMessage {
+	return (*MsgBeginRedelegate)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgBeginRedelegate) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddress != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddress)
+		if !f(fd_MsgBeginRedelegate_delegator_address, value) {
+			return
+		}
+	}
+	if x.ValidatorSrcAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorSrcAddress)
+		if !f(fd_MsgBeginRedelegate_validator_src_address, value) {
+			return
+		}
+	}
+	if x.ValidatorDstAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorDstAddress)
+		if !f(fd_MsgBeginRedelegate_validator_dst_address, value) {
+			return
+		}
+	}
+	if x.Amount != nil {
+		value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+		if !f(fd_MsgBeginRedelegate_amount, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgBeginRedelegate) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.delegator_address":
+		return x.DelegatorAddress != ""
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_src_address":
+		return x.ValidatorSrcAddress != ""
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_dst_address":
+		return x.ValidatorDstAddress != ""
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.amount":
+		return x.Amount != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBeginRedelegate) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.delegator_address":
+		x.DelegatorAddress = ""
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_src_address":
+		x.ValidatorSrcAddress = ""
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_dst_address":
+		x.ValidatorDstAddress = ""
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.amount":
+		x.Amount = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgBeginRedelegate) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.delegator_address":
+		value := x.DelegatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_src_address":
+		value := x.ValidatorSrcAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_dst_address":
+		value := x.ValidatorDstAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.amount":
+		value := x.Amount
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegate does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBeginRedelegate) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.delegator_address":
+		x.DelegatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_src_address":
+		x.ValidatorSrcAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_dst_address":
+		x.ValidatorDstAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.amount":
+		x.Amount = value.Message().Interface().(*v1beta1.Coin)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBeginRedelegate) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.amount":
+		if x.Amount == nil {
+			x.Amount = new(v1beta1.Coin)
+		}
+		return protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.delegator_address":
+		panic(fmt.Errorf("field delegator_address of message cosmos.staking.v1beta1.MsgBeginRedelegate is not mutable"))
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_src_address":
+		panic(fmt.Errorf("field validator_src_address of message cosmos.staking.v1beta1.MsgBeginRedelegate is not mutable"))
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_dst_address":
+		panic(fmt.Errorf("field validator_dst_address of message cosmos.staking.v1beta1.MsgBeginRedelegate is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgBeginRedelegate) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.delegator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_src_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.validator_dst_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgBeginRedelegate.amount":
+		m := new(v1beta1.Coin)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgBeginRedelegate) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgBeginRedelegate", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgBeginRedelegate) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBeginRedelegate) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgBeginRedelegate) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgBeginRedelegate) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgBeginRedelegate)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorSrcAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorDstAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Amount != nil {
+			l = options.Size(x.Amount)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgBeginRedelegate)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Amount != nil {
+			encoded, err := options.Marshal(x.Amount)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.ValidatorDstAddress) > 0 {
+			i -= len(x.ValidatorDstAddress)
+			copy(dAtA[i:], x.ValidatorDstAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorDstAddress)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.ValidatorSrcAddress) > 0 {
+			i -= len(x.ValidatorSrcAddress)
+			copy(dAtA[i:], x.ValidatorSrcAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorSrcAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddress) > 0 {
+			i -= len(x.DelegatorAddress)
+			copy(dAtA[i:], x.DelegatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddress)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgBeginRedelegate)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBeginRedelegate: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBeginRedelegate: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorSrcAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorSrcAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorDstAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorDstAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Amount == nil {
+					x.Amount = &v1beta1.Coin{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgBeginRedelegateResponse                 protoreflect.MessageDescriptor
+	fd_MsgBeginRedelegateResponse_completion_time protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgBeginRedelegateResponse = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgBeginRedelegateResponse")
+	fd_MsgBeginRedelegateResponse_completion_time = md_MsgBeginRedelegateResponse.Fields().ByName("completion_time")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgBeginRedelegateResponse)(nil)
+
+type fastReflection_MsgBeginRedelegateResponse MsgBeginRedelegateResponse
+
+func (x *MsgBeginRedelegateResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgBeginRedelegateResponse)(x)
+}
+
+func (x *MsgBeginRedelegateResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgBeginRedelegateResponse_messageType fastReflection_MsgBeginRedelegateResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgBeginRedelegateResponse_messageType{}
+
+type fastReflection_MsgBeginRedelegateResponse_messageType struct{}
+
+func (x fastReflection_MsgBeginRedelegateResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgBeginRedelegateResponse)(nil)
+}
+func (x fastReflection_MsgBeginRedelegateResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgBeginRedelegateResponse)
+}
+func (x fastReflection_MsgBeginRedelegateResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgBeginRedelegateResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgBeginRedelegateResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgBeginRedelegateResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgBeginRedelegateResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgBeginRedelegateResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgBeginRedelegateResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgBeginRedelegateResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgBeginRedelegateResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgBeginRedelegateResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgBeginRedelegateResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.CompletionTime != nil {
+		value := protoreflect.ValueOfMessage(x.CompletionTime.ProtoReflect())
+		if !f(fd_MsgBeginRedelegateResponse_completion_time, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgBeginRedelegateResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegateResponse.completion_time":
+		return x.CompletionTime != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBeginRedelegateResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegateResponse.completion_time":
+		x.CompletionTime = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgBeginRedelegateResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegateResponse.completion_time":
+		value := x.CompletionTime
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegateResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBeginRedelegateResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegateResponse.completion_time":
+		x.CompletionTime = value.Message().Interface().(*timestamppb.Timestamp)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBeginRedelegateResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegateResponse.completion_time":
+		if x.CompletionTime == nil {
+			x.CompletionTime = new(timestamppb.Timestamp)
+		}
+		return protoreflect.ValueOfMessage(x.CompletionTime.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgBeginRedelegateResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgBeginRedelegateResponse.completion_time":
+		m := new(timestamppb.Timestamp)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgBeginRedelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgBeginRedelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgBeginRedelegateResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgBeginRedelegateResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgBeginRedelegateResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBeginRedelegateResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgBeginRedelegateResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgBeginRedelegateResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgBeginRedelegateResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.CompletionTime != nil {
+			l = options.Size(x.CompletionTime)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgBeginRedelegateResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.CompletionTime != nil {
+			encoded, err := options.Marshal(x.CompletionTime)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgBeginRedelegateResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBeginRedelegateResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBeginRedelegateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.CompletionTime == nil {
+					x.CompletionTime = &timestamppb.Timestamp{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CompletionTime); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgUndelegate                   protoreflect.MessageDescriptor
+	fd_MsgUndelegate_delegator_address protoreflect.FieldDescriptor
+	fd_MsgUndelegate_validator_address protoreflect.FieldDescriptor
+	fd_MsgUndelegate_amount            protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgUndelegate = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgUndelegate")
+	fd_MsgUndelegate_delegator_address = md_MsgUndelegate.Fields().ByName("delegator_address")
+	fd_MsgUndelegate_validator_address = md_MsgUndelegate.Fields().ByName("validator_address")
+	fd_MsgUndelegate_amount = md_MsgUndelegate.Fields().ByName("amount")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUndelegate)(nil)
+
+type fastReflection_MsgUndelegate MsgUndelegate
+
+func (x *MsgUndelegate) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgUndelegate)(x)
+}
+
+func (x *MsgUndelegate) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgUndelegate_messageType fastReflection_MsgUndelegate_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUndelegate_messageType{}
+
+type fastReflection_MsgUndelegate_messageType struct{}
+
+func (x fastReflection_MsgUndelegate_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgUndelegate)(nil)
+}
+func (x fastReflection_MsgUndelegate_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgUndelegate)
+}
+func (x fastReflection_MsgUndelegate_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUndelegate
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUndelegate) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUndelegate
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgUndelegate) Type() protoreflect.MessageType {
+	return _fastReflection_MsgUndelegate_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUndelegate) New() protoreflect.Message {
+	return new(fastReflection_MsgUndelegate)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUndelegate) Interface() protoreflect.ProtoMessage {
+	return (*MsgUndelegate)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgUndelegate) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddress != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddress)
+		if !f(fd_MsgUndelegate_delegator_address, value) {
+			return
+		}
+	}
+	if x.ValidatorAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddress)
+		if !f(fd_MsgUndelegate_validator_address, value) {
+			return
+		}
+	}
+	if x.Amount != nil {
+		value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+		if !f(fd_MsgUndelegate_amount, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgUndelegate) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegate.delegator_address":
+		return x.DelegatorAddress != ""
+	case "cosmos.staking.v1beta1.MsgUndelegate.validator_address":
+		return x.ValidatorAddress != ""
+	case "cosmos.staking.v1beta1.MsgUndelegate.amount":
+		return x.Amount != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUndelegate) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegate.delegator_address":
+		x.DelegatorAddress = ""
+	case "cosmos.staking.v1beta1.MsgUndelegate.validator_address":
+		x.ValidatorAddress = ""
+	case "cosmos.staking.v1beta1.MsgUndelegate.amount":
+		x.Amount = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgUndelegate) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegate.delegator_address":
+		value := x.DelegatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgUndelegate.validator_address":
+		value := x.ValidatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgUndelegate.amount":
+		value := x.Amount
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegate does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUndelegate) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegate.delegator_address":
+		x.DelegatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgUndelegate.validator_address":
+		x.ValidatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgUndelegate.amount":
+		x.Amount = value.Message().Interface().(*v1beta1.Coin)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUndelegate) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegate.amount":
+		if x.Amount == nil {
+			x.Amount = new(v1beta1.Coin)
+		}
+		return protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgUndelegate.delegator_address":
+		panic(fmt.Errorf("field delegator_address of message cosmos.staking.v1beta1.MsgUndelegate is not mutable"))
+	case "cosmos.staking.v1beta1.MsgUndelegate.validator_address":
+		panic(fmt.Errorf("field validator_address of message cosmos.staking.v1beta1.MsgUndelegate is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgUndelegate) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegate.delegator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgUndelegate.validator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgUndelegate.amount":
+		m := new(v1beta1.Coin)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegate"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegate does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgUndelegate) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgUndelegate", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgUndelegate) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUndelegate) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgUndelegate) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgUndelegate) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgUndelegate)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Amount != nil {
+			l = options.Size(x.Amount)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgUndelegate)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Amount != nil {
+			encoded, err := options.Marshal(x.Amount)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.ValidatorAddress) > 0 {
+			i -= len(x.ValidatorAddress)
+			copy(dAtA[i:], x.ValidatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddress) > 0 {
+			i -= len(x.DelegatorAddress)
+			copy(dAtA[i:], x.DelegatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddress)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgUndelegate)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUndelegate: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUndelegate: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Amount == nil {
+					x.Amount = &v1beta1.Coin{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgUndelegateResponse                 protoreflect.MessageDescriptor
+	fd_MsgUndelegateResponse_completion_time protoreflect.FieldDescriptor
+	fd_MsgUndelegateResponse_amount          protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgUndelegateResponse = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgUndelegateResponse")
+	fd_MsgUndelegateResponse_completion_time = md_MsgUndelegateResponse.Fields().ByName("completion_time")
+	fd_MsgUndelegateResponse_amount = md_MsgUndelegateResponse.Fields().ByName("amount")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUndelegateResponse)(nil)
+
+type fastReflection_MsgUndelegateResponse MsgUndelegateResponse
+
+func (x *MsgUndelegateResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgUndelegateResponse)(x)
+}
+
+func (x *MsgUndelegateResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgUndelegateResponse_messageType fastReflection_MsgUndelegateResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUndelegateResponse_messageType{}
+
+type fastReflection_MsgUndelegateResponse_messageType struct{}
+
+func (x fastReflection_MsgUndelegateResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgUndelegateResponse)(nil)
+}
+func (x fastReflection_MsgUndelegateResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgUndelegateResponse)
+}
+func (x fastReflection_MsgUndelegateResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUndelegateResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUndelegateResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUndelegateResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgUndelegateResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgUndelegateResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUndelegateResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgUndelegateResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUndelegateResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgUndelegateResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgUndelegateResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.CompletionTime != nil {
+		value := protoreflect.ValueOfMessage(x.CompletionTime.ProtoReflect())
+		if !f(fd_MsgUndelegateResponse_completion_time, value) {
+			return
+		}
+	}
+	if x.Amount != nil {
+		value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+		if !f(fd_MsgUndelegateResponse_amount, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgUndelegateResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.completion_time":
+		return x.CompletionTime != nil
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.amount":
+		return x.Amount != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUndelegateResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.completion_time":
+		x.CompletionTime = nil
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.amount":
+		x.Amount = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgUndelegateResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.completion_time":
+		value := x.CompletionTime
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.amount":
+		value := x.Amount
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegateResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUndelegateResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.completion_time":
+		x.CompletionTime = value.Message().Interface().(*timestamppb.Timestamp)
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.amount":
+		x.Amount = value.Message().Interface().(*v1beta1.Coin)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUndelegateResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.completion_time":
+		if x.CompletionTime == nil {
+			x.CompletionTime = new(timestamppb.Timestamp)
+		}
+		return protoreflect.ValueOfMessage(x.CompletionTime.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.amount":
+		if x.Amount == nil {
+			x.Amount = new(v1beta1.Coin)
+		}
+		return protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgUndelegateResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.completion_time":
+		m := new(timestamppb.Timestamp)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgUndelegateResponse.amount":
+		m := new(v1beta1.Coin)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUndelegateResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUndelegateResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgUndelegateResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgUndelegateResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgUndelegateResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUndelegateResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgUndelegateResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgUndelegateResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgUndelegateResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.CompletionTime != nil {
+			l = options.Size(x.CompletionTime)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Amount != nil {
+			l = options.Size(x.Amount)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgUndelegateResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Amount != nil {
+			encoded, err := options.Marshal(x.Amount)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.CompletionTime != nil {
+			encoded, err := options.Marshal(x.CompletionTime)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgUndelegateResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUndelegateResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUndelegateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.CompletionTime == nil {
+					x.CompletionTime = &timestamppb.Timestamp{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CompletionTime); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Amount == nil {
+					x.Amount = &v1beta1.Coin{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgCancelUnbondingDelegation                   protoreflect.MessageDescriptor
+	fd_MsgCancelUnbondingDelegation_delegator_address protoreflect.FieldDescriptor
+	fd_MsgCancelUnbondingDelegation_validator_address protoreflect.FieldDescriptor
+	fd_MsgCancelUnbondingDelegation_amount            protoreflect.FieldDescriptor
+	fd_MsgCancelUnbondingDelegation_creation_height   protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgCancelUnbondingDelegation = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgCancelUnbondingDelegation")
+	fd_MsgCancelUnbondingDelegation_delegator_address = md_MsgCancelUnbondingDelegation.Fields().ByName("delegator_address")
+	fd_MsgCancelUnbondingDelegation_validator_address = md_MsgCancelUnbondingDelegation.Fields().ByName("validator_address")
+	fd_MsgCancelUnbondingDelegation_amount = md_MsgCancelUnbondingDelegation.Fields().ByName("amount")
+	fd_MsgCancelUnbondingDelegation_creation_height = md_MsgCancelUnbondingDelegation.Fields().ByName("creation_height")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgCancelUnbondingDelegation)(nil)
+
+type fastReflection_MsgCancelUnbondingDelegation MsgCancelUnbondingDelegation
+
+func (x *MsgCancelUnbondingDelegation) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCancelUnbondingDelegation)(x)
+}
+
+func (x *MsgCancelUnbondingDelegation) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgCancelUnbondingDelegation_messageType fastReflection_MsgCancelUnbondingDelegation_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCancelUnbondingDelegation_messageType{}
+
+type fastReflection_MsgCancelUnbondingDelegation_messageType struct{}
+
+func (x fastReflection_MsgCancelUnbondingDelegation_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCancelUnbondingDelegation)(nil)
+}
+func (x fastReflection_MsgCancelUnbondingDelegation_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelUnbondingDelegation)
+}
+func (x fastReflection_MsgCancelUnbondingDelegation_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelUnbondingDelegation
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgCancelUnbondingDelegation) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelUnbondingDelegation
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgCancelUnbondingDelegation) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCancelUnbondingDelegation_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgCancelUnbondingDelegation) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelUnbondingDelegation)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgCancelUnbondingDelegation) Interface() protoreflect.ProtoMessage {
+	return (*MsgCancelUnbondingDelegation)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgCancelUnbondingDelegation) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.DelegatorAddress != "" {
+		value := protoreflect.ValueOfString(x.DelegatorAddress)
+		if !f(fd_MsgCancelUnbondingDelegation_delegator_address, value) {
+			return
+		}
+	}
+	if x.ValidatorAddress != "" {
+		value := protoreflect.ValueOfString(x.ValidatorAddress)
+		if !f(fd_MsgCancelUnbondingDelegation_validator_address, value) {
+			return
+		}
+	}
+	if x.Amount != nil {
+		value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+		if !f(fd_MsgCancelUnbondingDelegation_amount, value) {
+			return
+		}
+	}
+	if x.CreationHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.CreationHeight)
+		if !f(fd_MsgCancelUnbondingDelegation_creation_height, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgCancelUnbondingDelegation) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.delegator_address":
+		return x.DelegatorAddress != ""
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.validator_address":
+		return x.ValidatorAddress != ""
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.amount":
+		return x.Amount != nil
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.creation_height":
+		return x.CreationHeight != int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCancelUnbondingDelegation) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.delegator_address":
+		x.DelegatorAddress = ""
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.validator_address":
+		x.ValidatorAddress = ""
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.amount":
+		x.Amount = nil
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.creation_height":
+		x.CreationHeight = int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgCancelUnbondingDelegation) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.delegator_address":
+		value := x.DelegatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.validator_address":
+		value := x.ValidatorAddress
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.amount":
+		value := x.Amount
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.creation_height":
+		value := x.CreationHeight
+		return protoreflect.ValueOfInt64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegation does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCancelUnbondingDelegation) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.delegator_address":
+		x.DelegatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.validator_address":
+		x.ValidatorAddress = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.amount":
+		x.Amount = value.Message().Interface().(*v1beta1.Coin)
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.creation_height":
+		x.CreationHeight = value.Int()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCancelUnbondingDelegation) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.amount":
+		if x.Amount == nil {
+			x.Amount = new(v1beta1.Coin)
+		}
+		return protoreflect.ValueOfMessage(x.Amount.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.delegator_address":
+		panic(fmt.Errorf("field delegator_address of message cosmos.staking.v1beta1.MsgCancelUnbondingDelegation is not mutable"))
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.validator_address":
+		panic(fmt.Errorf("field validator_address of message cosmos.staking.v1beta1.MsgCancelUnbondingDelegation is not mutable"))
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.creation_height":
+		panic(fmt.Errorf("field creation_height of message cosmos.staking.v1beta1.MsgCancelUnbondingDelegation is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgCancelUnbondingDelegation) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.delegator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.validator_address":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.amount":
+		m := new(v1beta1.Coin)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.creation_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegation"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegation does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgCancelUnbondingDelegation) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgCancelUnbondingDelegation", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgCancelUnbondingDelegation) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCancelUnbondingDelegation) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgCancelUnbondingDelegation) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgCancelUnbondingDelegation) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgCancelUnbondingDelegation)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.DelegatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ValidatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Amount != nil {
+			l = options.Size(x.Amount)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.CreationHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.CreationHeight))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgCancelUnbondingDelegation)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.CreationHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.CreationHeight))
+			i--
+			dAtA[i] = 0x20
+		}
+		if x.Amount != nil {
+			encoded, err := options.Marshal(x.Amount)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.ValidatorAddress) > 0 {
+			i -= len(x.ValidatorAddress)
+			copy(dAtA[i:], x.ValidatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.DelegatorAddress) > 0 {
+			i -= len(x.DelegatorAddress)
+			copy(dAtA[i:], x.DelegatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DelegatorAddress)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgCancelUnbondingDelegation)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelUnbondingDelegation: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelUnbondingDelegation: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Amount == nil {
+					x.Amount = &v1beta1.Coin{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType)
+				}
+				x.CreationHeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.CreationHeight |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgCancelUnbondingDelegationResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgCancelUnbondingDelegationResponse = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgCancelUnbondingDelegationResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgCancelUnbondingDelegationResponse)(nil)
+
+type fastReflection_MsgCancelUnbondingDelegationResponse MsgCancelUnbondingDelegationResponse
+
+func (x *MsgCancelUnbondingDelegationResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCancelUnbondingDelegationResponse)(x)
+}
+
+func (x *MsgCancelUnbondingDelegationResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgCancelUnbondingDelegationResponse_messageType fastReflection_MsgCancelUnbondingDelegationResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCancelUnbondingDelegationResponse_messageType{}
+
+type fastReflection_MsgCancelUnbondingDelegationResponse_messageType struct{}
+
+func (x fastReflection_MsgCancelUnbondingDelegationResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCancelUnbondingDelegationResponse)(nil)
+}
+func (x fastReflection_MsgCancelUnbondingDelegationResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelUnbondingDelegationResponse)
+}
+func (x fastReflection_MsgCancelUnbondingDelegationResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelUnbondingDelegationResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelUnbondingDelegationResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCancelUnbondingDelegationResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelUnbondingDelegationResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgCancelUnbondingDelegationResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgCancelUnbondingDelegationResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgCancelUnbondingDelegationResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgCancelUnbondingDelegationResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgCancelUnbondingDelegationResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelUnbondingDelegationResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelUnbondingDelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgUpdateParams           protoreflect.MessageDescriptor
+	fd_MsgUpdateParams_authority protoreflect.FieldDescriptor
+	fd_MsgUpdateParams_params    protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgUpdateParams = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgUpdateParams")
+	fd_MsgUpdateParams_authority = md_MsgUpdateParams.Fields().ByName("authority")
+	fd_MsgUpdateParams_params = md_MsgUpdateParams.Fields().ByName("params")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUpdateParams)(nil)
+
+type fastReflection_MsgUpdateParams MsgUpdateParams
+
+func (x *MsgUpdateParams) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgUpdateParams)(x)
+}
+
+func (x *MsgUpdateParams) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgUpdateParams_messageType fastReflection_MsgUpdateParams_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUpdateParams_messageType{}
+
+type fastReflection_MsgUpdateParams_messageType struct{}
+
+func (x fastReflection_MsgUpdateParams_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgUpdateParams)(nil)
+}
+func (x fastReflection_MsgUpdateParams_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgUpdateParams)
+}
+func (x fastReflection_MsgUpdateParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUpdateParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUpdateParams) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUpdateParams
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgUpdateParams) Type() protoreflect.MessageType {
+	return _fastReflection_MsgUpdateParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUpdateParams) New() protoreflect.Message {
+	return new(fastReflection_MsgUpdateParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUpdateParams) Interface() protoreflect.ProtoMessage {
+	return (*MsgUpdateParams)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgUpdateParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Authority != "" {
+		value := protoreflect.ValueOfString(x.Authority)
+		if !f(fd_MsgUpdateParams_authority, value) {
+			return
+		}
+	}
+	if x.Params != nil {
+		value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+		if !f(fd_MsgUpdateParams_params, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgUpdateParams) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUpdateParams.authority":
+		return x.Authority != ""
+	case "cosmos.staking.v1beta1.MsgUpdateParams.params":
+		return x.Params != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParams"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUpdateParams) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUpdateParams.authority":
+		x.Authority = ""
+	case "cosmos.staking.v1beta1.MsgUpdateParams.params":
+		x.Params = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParams"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgUpdateParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "cosmos.staking.v1beta1.MsgUpdateParams.authority":
+		value := x.Authority
+		return protoreflect.ValueOfString(value)
+	case "cosmos.staking.v1beta1.MsgUpdateParams.params":
+		value := x.Params
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParams"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParams does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUpdateParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUpdateParams.authority":
+		x.Authority = value.Interface().(string)
+	case "cosmos.staking.v1beta1.MsgUpdateParams.params":
+		x.Params = value.Message().Interface().(*Params)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParams"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUpdateParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUpdateParams.params":
+		if x.Params == nil {
+			x.Params = new(Params)
+		}
+		return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+	case "cosmos.staking.v1beta1.MsgUpdateParams.authority":
+		panic(fmt.Errorf("field authority of message cosmos.staking.v1beta1.MsgUpdateParams is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParams"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgUpdateParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "cosmos.staking.v1beta1.MsgUpdateParams.authority":
+		return protoreflect.ValueOfString("")
+	case "cosmos.staking.v1beta1.MsgUpdateParams.params":
+		m := new(Params)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParams"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgUpdateParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgUpdateParams", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgUpdateParams) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUpdateParams) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgUpdateParams) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgUpdateParams) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgUpdateParams)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Authority)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Params != nil {
+			l = options.Size(x.Params)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgUpdateParams)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Params != nil {
+			encoded, err := options.Marshal(x.Params)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.Authority) > 0 {
+			i -= len(x.Authority)
+			copy(dAtA[i:], x.Authority)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgUpdateParams)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Authority = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Params == nil {
+					x.Params = &Params{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Params); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgUpdateParamsResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+	file_cosmos_staking_v1beta1_tx_proto_init()
+	md_MsgUpdateParamsResponse = File_cosmos_staking_v1beta1_tx_proto.Messages().ByName("MsgUpdateParamsResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUpdateParamsResponse)(nil)
+
+type fastReflection_MsgUpdateParamsResponse MsgUpdateParamsResponse
+
+func (x *MsgUpdateParamsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgUpdateParamsResponse)(x)
+}
+
+func (x *MsgUpdateParamsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgUpdateParamsResponse_messageType fastReflection_MsgUpdateParamsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUpdateParamsResponse_messageType{}
+
+type fastReflection_MsgUpdateParamsResponse_messageType struct{}
+
+func (x fastReflection_MsgUpdateParamsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgUpdateParamsResponse)(nil)
+}
+func (x fastReflection_MsgUpdateParamsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgUpdateParamsResponse)
+}
+func (x fastReflection_MsgUpdateParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUpdateParamsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUpdateParamsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUpdateParamsResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgUpdateParamsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgUpdateParamsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUpdateParamsResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgUpdateParamsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUpdateParamsResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgUpdateParamsResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgUpdateParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgUpdateParamsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUpdateParamsResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgUpdateParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParamsResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUpdateParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUpdateParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgUpdateParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.staking.v1beta1.MsgUpdateParamsResponse"))
+		}
+		panic(fmt.Errorf("message cosmos.staking.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgUpdateParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in cosmos.staking.v1beta1.MsgUpdateParamsResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgUpdateParamsResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgUpdateParamsResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgUpdateParamsResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgUpdateParamsResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgUpdateParamsResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgUpdateParamsResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgUpdateParamsResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.0
+// 	protoc        (unknown)
+// source: cosmos/staking/v1beta1/tx.proto
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// MsgCreateValidator defines a SDK message for creating a new validator.
+type MsgCreateValidator struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Description       *Description     `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
+	Commission        *CommissionRates `protobuf:"bytes,2,opt,name=commission,proto3" json:"commission,omitempty"`
+	MinSelfDelegation string           `protobuf:"bytes,3,opt,name=min_self_delegation,json=minSelfDelegation,proto3" json:"min_self_delegation,omitempty"`
+	// Deprecated: Use of Delegator Address in MsgCreateValidator is deprecated.
+	// The validator address bytes and delegator address bytes refer to the same account while creating validator (defer
+	// only in bech32 notation).
+	//
+	// Deprecated: Do not use.
+	DelegatorAddress string        `protobuf:"bytes,4,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"`
+	ValidatorAddress string        `protobuf:"bytes,5,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
+	Pubkey           *anypb.Any    `protobuf:"bytes,6,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
+	Value            *v1beta1.Coin `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *MsgCreateValidator) Reset() {
+	*x = MsgCreateValidator{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgCreateValidator) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgCreateValidator) ProtoMessage() {}
+
+// Deprecated: Use MsgCreateValidator.ProtoReflect.Descriptor instead.
+func (*MsgCreateValidator) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *MsgCreateValidator) GetDescription() *Description {
+	if x != nil {
+		return x.Description
+	}
+	return nil
+}
+
+func (x *MsgCreateValidator) GetCommission() *CommissionRates {
+	if x != nil {
+		return x.Commission
+	}
+	return nil
+}
+
+func (x *MsgCreateValidator) GetMinSelfDelegation() string {
+	if x != nil {
+		return x.MinSelfDelegation
+	}
+	return ""
+}
+
+// Deprecated: Do not use.
+func (x *MsgCreateValidator) GetDelegatorAddress() string {
+	if x != nil {
+		return x.DelegatorAddress
+	}
+	return ""
+}
+
+func (x *MsgCreateValidator) GetValidatorAddress() string {
+	if x != nil {
+		return x.ValidatorAddress
+	}
+	return ""
+}
+
+func (x *MsgCreateValidator) GetPubkey() *anypb.Any {
+	if x != nil {
+		return x.Pubkey
+	}
+	return nil
+}
+
+func (x *MsgCreateValidator) GetValue() *v1beta1.Coin {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+// MsgCreateValidatorResponse defines the Msg/CreateValidator response type.
+type MsgCreateValidatorResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgCreateValidatorResponse) Reset() {
+	*x = MsgCreateValidatorResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgCreateValidatorResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgCreateValidatorResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgCreateValidatorResponse.ProtoReflect.Descriptor instead.
+func (*MsgCreateValidatorResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{1}
+}
+
+// MsgEditValidator defines a SDK message for editing an existing validator.
+type MsgEditValidator struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Description      *Description `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
+	ValidatorAddress string       `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
+	// We pass a reference to the new commission rate and min self delegation as
+	// it's not mandatory to update. If not updated, the deserialized rate will be
+	// zero with no way to distinguish if an update was intended.
+	// REF: #2373
+	CommissionRate    string `protobuf:"bytes,3,opt,name=commission_rate,json=commissionRate,proto3" json:"commission_rate,omitempty"`
+	MinSelfDelegation string `protobuf:"bytes,4,opt,name=min_self_delegation,json=minSelfDelegation,proto3" json:"min_self_delegation,omitempty"`
+}
+
+func (x *MsgEditValidator) Reset() {
+	*x = MsgEditValidator{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgEditValidator) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgEditValidator) ProtoMessage() {}
+
+// Deprecated: Use MsgEditValidator.ProtoReflect.Descriptor instead.
+func (*MsgEditValidator) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *MsgEditValidator) GetDescription() *Description {
+	if x != nil {
+		return x.Description
+	}
+	return nil
+}
+
+func (x *MsgEditValidator) GetValidatorAddress() string {
+	if x != nil {
+		return x.ValidatorAddress
+	}
+	return ""
+}
+
+func (x *MsgEditValidator) GetCommissionRate() string {
+	if x != nil {
+		return x.CommissionRate
+	}
+	return ""
+}
+
+func (x *MsgEditValidator) GetMinSelfDelegation() string {
+	if x != nil {
+		return x.MinSelfDelegation
+	}
+	return ""
+}
+
+// MsgEditValidatorResponse defines the Msg/EditValidator response type.
+type MsgEditValidatorResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgEditValidatorResponse) Reset() {
+	*x = MsgEditValidatorResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgEditValidatorResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgEditValidatorResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgEditValidatorResponse.ProtoReflect.Descriptor instead.
+func (*MsgEditValidatorResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{3}
+}
+
+// MsgDelegate defines a SDK message for performing a delegation of coins
+// from a delegator to a validator.
+type MsgDelegate struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	DelegatorAddress string        `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"`
+	ValidatorAddress string        `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
+	Amount           *v1beta1.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
+}
+
+func (x *MsgDelegate) Reset() {
+	*x = MsgDelegate{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgDelegate) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgDelegate) ProtoMessage() {}
+
+// Deprecated: Use MsgDelegate.ProtoReflect.Descriptor instead.
+func (*MsgDelegate) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *MsgDelegate) GetDelegatorAddress() string {
+	if x != nil {
+		return x.DelegatorAddress
+	}
+	return ""
+}
+
+func (x *MsgDelegate) GetValidatorAddress() string {
+	if x != nil {
+		return x.ValidatorAddress
+	}
+	return ""
+}
+
+func (x *MsgDelegate) GetAmount() *v1beta1.Coin {
+	if x != nil {
+		return x.Amount
+	}
+	return nil
+}
+
+// MsgDelegateResponse defines the Msg/Delegate response type.
+type MsgDelegateResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgDelegateResponse) Reset() {
+	*x = MsgDelegateResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgDelegateResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgDelegateResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgDelegateResponse.ProtoReflect.Descriptor instead.
+func (*MsgDelegateResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{5}
+}
+
+// MsgBeginRedelegate defines a SDK message for performing a redelegation
+// of coins from a delegator and source validator to a destination validator.
+type MsgBeginRedelegate struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	DelegatorAddress    string        `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"`
+	ValidatorSrcAddress string        `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty"`
+	ValidatorDstAddress string        `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty"`
+	Amount              *v1beta1.Coin `protobuf:"bytes,4,opt,name=amount,proto3" json:"amount,omitempty"`
+}
+
+func (x *MsgBeginRedelegate) Reset() {
+	*x = MsgBeginRedelegate{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgBeginRedelegate) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgBeginRedelegate) ProtoMessage() {}
+
+// Deprecated: Use MsgBeginRedelegate.ProtoReflect.Descriptor instead.
+func (*MsgBeginRedelegate) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *MsgBeginRedelegate) GetDelegatorAddress() string {
+	if x != nil {
+		return x.DelegatorAddress
+	}
+	return ""
+}
+
+func (x *MsgBeginRedelegate) GetValidatorSrcAddress() string {
+	if x != nil {
+		return x.ValidatorSrcAddress
+	}
+	return ""
+}
+
+func (x *MsgBeginRedelegate) GetValidatorDstAddress() string {
+	if x != nil {
+		return x.ValidatorDstAddress
+	}
+	return ""
+}
+
+func (x *MsgBeginRedelegate) GetAmount() *v1beta1.Coin {
+	if x != nil {
+		return x.Amount
+	}
+	return nil
+}
+
+// MsgBeginRedelegateResponse defines the Msg/BeginRedelegate response type.
+type MsgBeginRedelegateResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	CompletionTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=completion_time,json=completionTime,proto3" json:"completion_time,omitempty"`
+}
+
+func (x *MsgBeginRedelegateResponse) Reset() {
+	*x = MsgBeginRedelegateResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgBeginRedelegateResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgBeginRedelegateResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgBeginRedelegateResponse.ProtoReflect.Descriptor instead.
+func (*MsgBeginRedelegateResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *MsgBeginRedelegateResponse) GetCompletionTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.CompletionTime
+	}
+	return nil
+}
+
+// MsgUndelegate defines a SDK message for performing an undelegation from a
+// delegate and a validator.
+type MsgUndelegate struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	DelegatorAddress string        `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"`
+	ValidatorAddress string        `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
+	Amount           *v1beta1.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
+}
+
+func (x *MsgUndelegate) Reset() {
+	*x = MsgUndelegate{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgUndelegate) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUndelegate) ProtoMessage() {}
+
+// Deprecated: Use MsgUndelegate.ProtoReflect.Descriptor instead.
+func (*MsgUndelegate) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *MsgUndelegate) GetDelegatorAddress() string {
+	if x != nil {
+		return x.DelegatorAddress
+	}
+	return ""
+}
+
+func (x *MsgUndelegate) GetValidatorAddress() string {
+	if x != nil {
+		return x.ValidatorAddress
+	}
+	return ""
+}
+
+func (x *MsgUndelegate) GetAmount() *v1beta1.Coin {
+	if x != nil {
+		return x.Amount
+	}
+	return nil
+}
+
+// MsgUndelegateResponse defines the Msg/Undelegate response type.
+type MsgUndelegateResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	CompletionTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=completion_time,json=completionTime,proto3" json:"completion_time,omitempty"`
+	// amount returns the amount of undelegated coins
+	//
+	// Since: cosmos-sdk 0.50
+	Amount *v1beta1.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
+}
+
+func (x *MsgUndelegateResponse) Reset() {
+	*x = MsgUndelegateResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgUndelegateResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUndelegateResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgUndelegateResponse.ProtoReflect.Descriptor instead.
+func (*MsgUndelegateResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *MsgUndelegateResponse) GetCompletionTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.CompletionTime
+	}
+	return nil
+}
+
+func (x *MsgUndelegateResponse) GetAmount() *v1beta1.Coin {
+	if x != nil {
+		return x.Amount
+	}
+	return nil
+}
+
+// MsgCancelUnbondingDelegation defines the SDK message for performing a cancel unbonding delegation for delegator
+//
+// Since: cosmos-sdk 0.46
+type MsgCancelUnbondingDelegation struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"`
+	ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
+	// amount is always less than or equal to unbonding delegation entry balance
+	Amount *v1beta1.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
+	// creation_height is the height which the unbonding took place.
+	CreationHeight int64 `protobuf:"varint,4,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty"`
+}
+
+func (x *MsgCancelUnbondingDelegation) Reset() {
+	*x = MsgCancelUnbondingDelegation{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgCancelUnbondingDelegation) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgCancelUnbondingDelegation) ProtoMessage() {}
+
+// Deprecated: Use MsgCancelUnbondingDelegation.ProtoReflect.Descriptor instead.
+func (*MsgCancelUnbondingDelegation) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *MsgCancelUnbondingDelegation) GetDelegatorAddress() string {
+	if x != nil {
+		return x.DelegatorAddress
+	}
+	return ""
+}
+
+func (x *MsgCancelUnbondingDelegation) GetValidatorAddress() string {
+	if x != nil {
+		return x.ValidatorAddress
+	}
+	return ""
+}
+
+func (x *MsgCancelUnbondingDelegation) GetAmount() *v1beta1.Coin {
+	if x != nil {
+		return x.Amount
+	}
+	return nil
+}
+
+func (x *MsgCancelUnbondingDelegation) GetCreationHeight() int64 {
+	if x != nil {
+		return x.CreationHeight
+	}
+	return 0
+}
+
+// MsgCancelUnbondingDelegationResponse
+//
+// Since: cosmos-sdk 0.46
+type MsgCancelUnbondingDelegationResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgCancelUnbondingDelegationResponse) Reset() {
+	*x = MsgCancelUnbondingDelegationResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgCancelUnbondingDelegationResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgCancelUnbondingDelegationResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgCancelUnbondingDelegationResponse.ProtoReflect.Descriptor instead.
+func (*MsgCancelUnbondingDelegationResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{11}
+}
+
+// MsgUpdateParams is the Msg/UpdateParams request type.
+//
+// Since: cosmos-sdk 0.47
+type MsgUpdateParams struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// authority is the address that controls the module (defaults to x/gov unless overwritten).
+	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+	// params defines the x/staking parameters to update.
+	//
+	// NOTE: All parameters must be supplied.
+	Params *Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
+}
+
+func (x *MsgUpdateParams) Reset() {
+	*x = MsgUpdateParams{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgUpdateParams) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUpdateParams) ProtoMessage() {}
+
+// Deprecated: Use MsgUpdateParams.ProtoReflect.Descriptor instead.
+func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *MsgUpdateParams) GetAuthority() string {
+	if x != nil {
+		return x.Authority
+	}
+	return ""
+}
+
+func (x *MsgUpdateParams) GetParams() *Params {
+	if x != nil {
+		return x.Params
+	}
+	return nil
+}
+
+// MsgUpdateParamsResponse defines the response structure for executing a
+// MsgUpdateParams message.
+//
+// Since: cosmos-sdk 0.47
+type MsgUpdateParamsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgUpdateParamsResponse) Reset() {
+	*x = MsgUpdateParamsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_cosmos_staking_v1beta1_tx_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgUpdateParamsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUpdateParamsResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgUpdateParamsResponse.ProtoReflect.Descriptor instead.
+func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP(), []int{13}
+}
+
+var File_cosmos_staking_v1beta1_tx_proto protoreflect.FileDescriptor
+
+var file_cosmos_staking_v1beta1_tx_proto_rawDesc = []byte{
+	0x0a, 0x1f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x12, 0x16, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e,
+	0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62,
+	0x61, 0x73, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6f, 0x69, 0x6e,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x73, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73, 0x67, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69,
+	0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xfb, 0x04, 0x0a, 0x12, 0x4d, 0x73, 0x67,
+	0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x12,
+	0x50, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74,
+	0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65,
+	0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8,
+	0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x12, 0x52, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73,
+	0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43,
+	0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x73, 0x42, 0x09,
+	0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69,
+	0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x60, 0x0a, 0x13, 0x6d, 0x69, 0x6e, 0x5f, 0x73, 0x65, 0x6c,
+	0x66, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x09, 0x42, 0x30, 0xc8, 0xde, 0x1f, 0x00, 0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e,
+	0x74, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0xa8,
+	0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x11, 0x6d, 0x69, 0x6e, 0x53, 0x65, 0x6c, 0x66, 0x44, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x47, 0x0a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x09, 0x42, 0x1a, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x52, 0x10,
+	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x12, 0x4e, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d,
+	0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
+	0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10,
+	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x12, 0x46, 0x0a, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x42, 0x18, 0xca, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79,
+	0x52, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x3a, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f,
+	0x69, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x3a, 0x40, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x82, 0xe7,
+	0xb0, 0x2a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x8a, 0xe7, 0xb0, 0x2a, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d,
+	0x73, 0x64, 0x6b, 0x2f, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x1c, 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65,
+	0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa5, 0x03, 0x0a, 0x10, 0x4d, 0x73, 0x67, 0x45, 0x64, 0x69, 0x74,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x50, 0x0a, 0x0b, 0x64, 0x65, 0x73,
+	0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23,
+	0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
+	0x69, 0x6f, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0b,
+	0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4e, 0x0a, 0x11, 0x76,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x56, 0x0a, 0x0f, 0x63,
+	0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x09, 0x42, 0x2d, 0xda, 0xde, 0x1f, 0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x4c, 0x65, 0x67, 0x61,
+	0x63, 0x79, 0x44, 0x65, 0x63, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x44, 0x65, 0x63, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52,
+	0x61, 0x74, 0x65, 0x12, 0x57, 0x0a, 0x13, 0x6d, 0x69, 0x6e, 0x5f, 0x73, 0x65, 0x6c, 0x66, 0x5f,
+	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
+	0x42, 0x27, 0xda, 0xde, 0x1f, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e,
+	0x69, 0x6f, 0x2f, 0x6d, 0x61, 0x74, 0x68, 0x2e, 0x49, 0x6e, 0x74, 0xd2, 0xb4, 0x2d, 0x0a, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x52, 0x11, 0x6d, 0x69, 0x6e, 0x53, 0x65,
+	0x6c, 0x66, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x3e, 0x88, 0xa0,
+	0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x82, 0xe7, 0xb0, 0x2a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x8a, 0xe7, 0xb0, 0x2a,
+	0x1b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x4d, 0x73, 0x67, 0x45,
+	0x64, 0x69, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x1a, 0x0a, 0x18,
+	0x4d, 0x73, 0x67, 0x45, 0x64, 0x69, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x9d, 0x02, 0x0a, 0x0b, 0x4d, 0x73, 0x67,
+	0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12, 0x45, 0x0a, 0x11, 0x64, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x64,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12,
+	0x4e, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x76,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12,
+	0x3c, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00,
+	0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x39, 0x88,
+	0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x82, 0xe7, 0xb0, 0x2a, 0x11, 0x64, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x8a, 0xe7, 0xb0,
+	0x2a, 0x16, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x4d, 0x73, 0x67,
+	0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x22, 0x15, 0x0a, 0x13, 0x4d, 0x73, 0x67, 0x44,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x89, 0x03, 0x0a, 0x12, 0x4d, 0x73, 0x67, 0x42, 0x65, 0x67, 0x69, 0x6e, 0x52, 0x65, 0x64, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12, 0x45, 0x0a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x64, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x55, 0x0a,
+	0x15, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x73, 0x72, 0x63, 0x5f, 0x61,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4,
+	0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52,
+	0x13, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x72, 0x63, 0x41, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x12, 0x55, 0x0a, 0x15, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
+	0x72, 0x5f, 0x64, 0x73, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x13, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
+	0x72, 0x44, 0x73, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x3c, 0x0a, 0x06, 0x61,
+	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a,
+	0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x40, 0x88, 0xa0, 0x1f, 0x00, 0xe8,
+	0xa0, 0x1f, 0x00, 0x82, 0xe7, 0xb0, 0x2a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f,
+	0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x8a, 0xe7, 0xb0, 0x2a, 0x1d, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x4d, 0x73, 0x67, 0x42, 0x65, 0x67, 0x69,
+	0x6e, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x22, 0x70, 0x0a, 0x1a, 0x4d,
+	0x73, 0x67, 0x42, 0x65, 0x67, 0x69, 0x6e, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x52, 0x0a, 0x0f, 0x63, 0x6f, 0x6d,
+	0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x0d,
+	0xc8, 0xde, 0x1f, 0x00, 0x90, 0xdf, 0x1f, 0x01, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0e, 0x63,
+	0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xa1, 0x02,
+	0x0a, 0x0d, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12,
+	0x45, 0x0a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x4e, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74,
+	0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x3c, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69,
+	0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, 0x6d,
+	0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x3b, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x82, 0xe7,
+	0xb0, 0x2a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x8a, 0xe7, 0xb0, 0x2a, 0x18, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d,
+	0x73, 0x64, 0x6b, 0x2f, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x65, 0x22, 0xa9, 0x01, 0x0a, 0x15, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x64, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x52, 0x0a, 0x0f, 0x63,
+	0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
+	0x42, 0x0d, 0xc8, 0xde, 0x1f, 0x00, 0x90, 0xdf, 0x1f, 0x01, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52,
+	0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12,
+	0x3c, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00,
+	0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xe8, 0x02,
+	0x0a, 0x1c, 0x4d, 0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x55, 0x6e, 0x62, 0x6f, 0x6e,
+	0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x45,
+	0x0a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x52, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x4e, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72,
+	0x69, 0x6e, 0x67, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x3c, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62,
+	0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e,
+	0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f,
+	0x75, 0x6e, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+	0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x63, 0x72,
+	0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x4a, 0x88, 0xa0,
+	0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x82, 0xe7, 0xb0, 0x2a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x8a, 0xe7, 0xb0, 0x2a,
+	0x27, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x4d, 0x73, 0x67, 0x43,
+	0x61, 0x6e, 0x63, 0x65, 0x6c, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x26, 0x0a, 0x24, 0x4d, 0x73, 0x67, 0x43,
+	0x61, 0x6e, 0x63, 0x65, 0x6c, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0xc5, 0x01, 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61,
+	0x72, 0x61, 0x6d, 0x73, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x41, 0x0a, 0x06,
+	0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x09, 0xc8, 0xde,
+	0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x3a,
+	0x37, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a,
+	0xe7, 0xb0, 0x2a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x78,
+	0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61,
+	0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x55,
+	0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x32, 0x9d, 0x06, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x71, 0x0a, 0x0f, 0x43,
+	0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x2a,
+	0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74,
+	0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x1a, 0x32, 0x2e, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65,
+	0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6b,
+	0x0a, 0x0d, 0x45, 0x64, 0x69, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x12,
+	0x28, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67,
+	0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x45, 0x64, 0x69, 0x74,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x1a, 0x30, 0x2e, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x45, 0x64, 0x69, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a, 0x08, 0x44,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12, 0x23, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x1a, 0x2b, 0x2e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x71, 0x0a, 0x0f, 0x42, 0x65, 0x67,
+	0x69, 0x6e, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12, 0x2a, 0x2e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x65, 0x67, 0x69, 0x6e, 0x52, 0x65,
+	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x1a, 0x32, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x65, 0x67, 0x69, 0x6e, 0x52, 0x65, 0x64, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a, 0x0a,
+	0x55, 0x6e, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12, 0x25, 0x2e, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65,
+	0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x65, 0x1a, 0x2d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69,
+	0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x6e,
+	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x8f, 0x01, 0x0a, 0x19, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x55, 0x6e, 0x62, 0x6f, 0x6e,
+	0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x34,
+	0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65,
+	0x6c, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x3c, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74,
+	0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73,
+	0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x55, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67,
+	0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x68, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61,
+	0x6d, 0x73, 0x12, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b,
+	0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55,
+	0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x2f, 0x2e, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61,
+	0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05, 0x80, 0xe7,
+	0xb0, 0x2a, 0x01, 0x42, 0xd7, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x36, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2f, 0x76,
+	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x73, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x53, 0x58, 0xaa, 0x02, 0x16, 0x43, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x56, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0xca, 0x02, 0x16, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x74,
+	0x61, 0x6b, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, 0x22,
+	0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x5c, 0x56,
+	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
+	0x74, 0x61, 0xea, 0x02, 0x18, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x53, 0x74, 0x61,
+	0x6b, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x62, 0x06, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_cosmos_staking_v1beta1_tx_proto_rawDescOnce sync.Once
+	file_cosmos_staking_v1beta1_tx_proto_rawDescData = file_cosmos_staking_v1beta1_tx_proto_rawDesc
+)
+
+func file_cosmos_staking_v1beta1_tx_proto_rawDescGZIP() []byte {
+	file_cosmos_staking_v1beta1_tx_proto_rawDescOnce.Do(func() {
+		file_cosmos_staking_v1beta1_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_cosmos_staking_v1beta1_tx_proto_rawDescData)
+	})
+	return file_cosmos_staking_v1beta1_tx_proto_rawDescData
+}
+
+var file_cosmos_staking_v1beta1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 14)
+var file_cosmos_staking_v1beta1_tx_proto_goTypes = []interface{}{
+	(*MsgCreateValidator)(nil),                   // 0: cosmos.staking.v1beta1.MsgCreateValidator
+	(*MsgCreateValidatorResponse)(nil),           // 1: cosmos.staking.v1beta1.MsgCreateValidatorResponse
+	(*MsgEditValidator)(nil),                     // 2: cosmos.staking.v1beta1.MsgEditValidator
+	(*MsgEditValidatorResponse)(nil),             // 3: cosmos.staking.v1beta1.MsgEditValidatorResponse
+	(*MsgDelegate)(nil),                          // 4: cosmos.staking.v1beta1.MsgDelegate
+	(*MsgDelegateResponse)(nil),                  // 5: cosmos.staking.v1beta1.MsgDelegateResponse
+	(*MsgBeginRedelegate)(nil),                   // 6: cosmos.staking.v1beta1.MsgBeginRedelegate
+	(*MsgBeginRedelegateResponse)(nil),           // 7: cosmos.staking.v1beta1.MsgBeginRedelegateResponse
+	(*MsgUndelegate)(nil),                        // 8: cosmos.staking.v1beta1.MsgUndelegate
+	(*MsgUndelegateResponse)(nil),                // 9: cosmos.staking.v1beta1.MsgUndelegateResponse
+	(*MsgCancelUnbondingDelegation)(nil),         // 10: cosmos.staking.v1beta1.MsgCancelUnbondingDelegation
+	(*MsgCancelUnbondingDelegationResponse)(nil), // 11: cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse
+	(*MsgUpdateParams)(nil),                      // 12: cosmos.staking.v1beta1.MsgUpdateParams
+	(*MsgUpdateParamsResponse)(nil),              // 13: cosmos.staking.v1beta1.MsgUpdateParamsResponse
+	(*Description)(nil),                          // 14: cosmos.staking.v1beta1.Description
+	(*CommissionRates)(nil),                      // 15: cosmos.staking.v1beta1.CommissionRates
+	(*anypb.Any)(nil),                            // 16: google.protobuf.Any
+	(*v1beta1.Coin)(nil),                         // 17: cosmos.base.v1beta1.Coin
+	(*timestamppb.Timestamp)(nil),                // 18: google.protobuf.Timestamp
+	(*Params)(nil),                               // 19: cosmos.staking.v1beta1.Params
+}
+var file_cosmos_staking_v1beta1_tx_proto_depIdxs = []int32{
+	14, // 0: cosmos.staking.v1beta1.MsgCreateValidator.description:type_name -> cosmos.staking.v1beta1.Description
+	15, // 1: cosmos.staking.v1beta1.MsgCreateValidator.commission:type_name -> cosmos.staking.v1beta1.CommissionRates
+	16, // 2: cosmos.staking.v1beta1.MsgCreateValidator.pubkey:type_name -> google.protobuf.Any
+	17, // 3: cosmos.staking.v1beta1.MsgCreateValidator.value:type_name -> cosmos.base.v1beta1.Coin
+	14, // 4: cosmos.staking.v1beta1.MsgEditValidator.description:type_name -> cosmos.staking.v1beta1.Description
+	17, // 5: cosmos.staking.v1beta1.MsgDelegate.amount:type_name -> cosmos.base.v1beta1.Coin
+	17, // 6: cosmos.staking.v1beta1.MsgBeginRedelegate.amount:type_name -> cosmos.base.v1beta1.Coin
+	18, // 7: cosmos.staking.v1beta1.MsgBeginRedelegateResponse.completion_time:type_name -> google.protobuf.Timestamp
+	17, // 8: cosmos.staking.v1beta1.MsgUndelegate.amount:type_name -> cosmos.base.v1beta1.Coin
+	18, // 9: cosmos.staking.v1beta1.MsgUndelegateResponse.completion_time:type_name -> google.protobuf.Timestamp
+	17, // 10: cosmos.staking.v1beta1.MsgUndelegateResponse.amount:type_name -> cosmos.base.v1beta1.Coin
+	17, // 11: cosmos.staking.v1beta1.MsgCancelUnbondingDelegation.amount:type_name -> cosmos.base.v1beta1.Coin
+	19, // 12: cosmos.staking.v1beta1.MsgUpdateParams.params:type_name -> cosmos.staking.v1beta1.Params
+	0,  // 13: cosmos.staking.v1beta1.Msg.CreateValidator:input_type -> cosmos.staking.v1beta1.MsgCreateValidator
+	2,  // 14: cosmos.staking.v1beta1.Msg.EditValidator:input_type -> cosmos.staking.v1beta1.MsgEditValidator
+	4,  // 15: cosmos.staking.v1beta1.Msg.Delegate:input_type -> cosmos.staking.v1beta1.MsgDelegate
+	6,  // 16: cosmos.staking.v1beta1.Msg.BeginRedelegate:input_type -> cosmos.staking.v1beta1.MsgBeginRedelegate
+	8,  // 17: cosmos.staking.v1beta1.Msg.Undelegate:input_type -> cosmos.staking.v1beta1.MsgUndelegate
+	10, // 18: cosmos.staking.v1beta1.Msg.CancelUnbondingDelegation:input_type -> cosmos.staking.v1beta1.MsgCancelUnbondingDelegation
+	12, // 19: cosmos.staking.v1beta1.Msg.UpdateParams:input_type -> cosmos.staking.v1beta1.MsgUpdateParams
+	1,  // 20: cosmos.staking.v1beta1.Msg.CreateValidator:output_type -> cosmos.staking.v1beta1.MsgCreateValidatorResponse
+	3,  // 21: cosmos.staking.v1beta1.Msg.EditValidator:output_type -> cosmos.staking.v1beta1.MsgEditValidatorResponse
+	5,  // 22: cosmos.staking.v1beta1.Msg.Delegate:output_type -> cosmos.staking.v1beta1.MsgDelegateResponse
+	7,  // 23: cosmos.staking.v1beta1.Msg.BeginRedelegate:output_type -> cosmos.staking.v1beta1.MsgBeginRedelegateResponse
+	9,  // 24: cosmos.staking.v1beta1.Msg.Undelegate:output_type -> cosmos.staking.v1beta1.MsgUndelegateResponse
+	11, // 25: cosmos.staking.v1beta1.Msg.CancelUnbondingDelegation:output_type -> cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse
+	13, // 26: cosmos.staking.v1beta1.Msg.UpdateParams:output_type -> cosmos.staking.v1beta1.MsgUpdateParamsResponse
+	20, // [20:27] is the sub-list for method output_type
+	13, // [13:20] is the sub-list for method input_type
+	13, // [13:13] is the sub-list for extension type_name
+	13, // [13:13] is the sub-list for extension extendee
+	0,  // [0:13] is the sub-list for field type_name
+}
+
+func init() { file_cosmos_staking_v1beta1_tx_proto_init() }
+func file_cosmos_staking_v1beta1_tx_proto_init() {
+	if File_cosmos_staking_v1beta1_tx_proto != nil {
+		return
+	}
+	file_cosmos_staking_v1beta1_staking_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgCreateValidator); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgCreateValidatorResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgEditValidator); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgEditValidatorResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgDelegate); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgDelegateResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgBeginRedelegate); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgBeginRedelegateResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgUndelegate); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgUndelegateResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgCancelUnbondingDelegation); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgCancelUnbondingDelegationResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgUpdateParams); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_cosmos_staking_v1beta1_tx_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgUpdateParamsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_cosmos_staking_v1beta1_tx_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   14,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_cosmos_staking_v1beta1_tx_proto_goTypes,
+		DependencyIndexes: file_cosmos_staking_v1beta1_tx_proto_depIdxs,
+		MessageInfos:      file_cosmos_staking_v1beta1_tx_proto_msgTypes,
+	}.Build()
+	File_cosmos_staking_v1beta1_tx_proto = out.File
+	file_cosmos_staking_v1beta1_tx_proto_rawDesc = nil
+	file_cosmos_staking_v1beta1_tx_proto_goTypes = nil
+	file_cosmos_staking_v1beta1_tx_proto_depIdxs = nil
+}
diff --git a/atomone-api/cosmos/staking/v1beta1/tx_grpc.pb.go b/atomone-api/cosmos/staking/v1beta1/tx_grpc.pb.go
new file mode 100644
index 000000000000..a177942078ca
--- /dev/null
+++ b/atomone-api/cosmos/staking/v1beta1/tx_grpc.pb.go
@@ -0,0 +1,383 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.5.1
+// - protoc             (unknown)
+// source: cosmos/staking/v1beta1/tx.proto
+
+package stakingv1beta1
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	Msg_CreateValidator_FullMethodName           = "/cosmos.staking.v1beta1.Msg/CreateValidator"
+	Msg_EditValidator_FullMethodName             = "/cosmos.staking.v1beta1.Msg/EditValidator"
+	Msg_Delegate_FullMethodName                  = "/cosmos.staking.v1beta1.Msg/Delegate"
+	Msg_BeginRedelegate_FullMethodName           = "/cosmos.staking.v1beta1.Msg/BeginRedelegate"
+	Msg_Undelegate_FullMethodName                = "/cosmos.staking.v1beta1.Msg/Undelegate"
+	Msg_CancelUnbondingDelegation_FullMethodName = "/cosmos.staking.v1beta1.Msg/CancelUnbondingDelegation"
+	Msg_UpdateParams_FullMethodName              = "/cosmos.staking.v1beta1.Msg/UpdateParams"
+)
+
+// MsgClient is the client API for Msg service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+//
+// Msg defines the staking Msg service.
+type MsgClient interface {
+	// CreateValidator defines a method for creating a new validator.
+	CreateValidator(ctx context.Context, in *MsgCreateValidator, opts ...grpc.CallOption) (*MsgCreateValidatorResponse, error)
+	// EditValidator defines a method for editing an existing validator.
+	EditValidator(ctx context.Context, in *MsgEditValidator, opts ...grpc.CallOption) (*MsgEditValidatorResponse, error)
+	// Delegate defines a method for performing a delegation of coins
+	// from a delegator to a validator.
+	Delegate(ctx context.Context, in *MsgDelegate, opts ...grpc.CallOption) (*MsgDelegateResponse, error)
+	// BeginRedelegate defines a method for performing a redelegation
+	// of coins from a delegator and source validator to a destination validator.
+	BeginRedelegate(ctx context.Context, in *MsgBeginRedelegate, opts ...grpc.CallOption) (*MsgBeginRedelegateResponse, error)
+	// Undelegate defines a method for performing an undelegation from a
+	// delegate and a validator.
+	Undelegate(ctx context.Context, in *MsgUndelegate, opts ...grpc.CallOption) (*MsgUndelegateResponse, error)
+	// CancelUnbondingDelegation defines a method for performing canceling the unbonding delegation
+	// and delegate back to previous validator.
+	//
+	// Since: cosmos-sdk 0.46
+	CancelUnbondingDelegation(ctx context.Context, in *MsgCancelUnbondingDelegation, opts ...grpc.CallOption) (*MsgCancelUnbondingDelegationResponse, error)
+	// UpdateParams defines an operation for updating the x/staking module
+	// parameters.
+	// Since: cosmos-sdk 0.47
+	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
+}
+
+type msgClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewMsgClient(cc grpc.ClientConnInterface) MsgClient {
+	return &msgClient{cc}
+}
+
+func (c *msgClient) CreateValidator(ctx context.Context, in *MsgCreateValidator, opts ...grpc.CallOption) (*MsgCreateValidatorResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(MsgCreateValidatorResponse)
+	err := c.cc.Invoke(ctx, Msg_CreateValidator_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *msgClient) EditValidator(ctx context.Context, in *MsgEditValidator, opts ...grpc.CallOption) (*MsgEditValidatorResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(MsgEditValidatorResponse)
+	err := c.cc.Invoke(ctx, Msg_EditValidator_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *msgClient) Delegate(ctx context.Context, in *MsgDelegate, opts ...grpc.CallOption) (*MsgDelegateResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(MsgDelegateResponse)
+	err := c.cc.Invoke(ctx, Msg_Delegate_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *msgClient) BeginRedelegate(ctx context.Context, in *MsgBeginRedelegate, opts ...grpc.CallOption) (*MsgBeginRedelegateResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(MsgBeginRedelegateResponse)
+	err := c.cc.Invoke(ctx, Msg_BeginRedelegate_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *msgClient) Undelegate(ctx context.Context, in *MsgUndelegate, opts ...grpc.CallOption) (*MsgUndelegateResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(MsgUndelegateResponse)
+	err := c.cc.Invoke(ctx, Msg_Undelegate_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *msgClient) CancelUnbondingDelegation(ctx context.Context, in *MsgCancelUnbondingDelegation, opts ...grpc.CallOption) (*MsgCancelUnbondingDelegationResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(MsgCancelUnbondingDelegationResponse)
+	err := c.cc.Invoke(ctx, Msg_CancelUnbondingDelegation_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(MsgUpdateParamsResponse)
+	err := c.cc.Invoke(ctx, Msg_UpdateParams_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// MsgServer is the server API for Msg service.
+// All implementations must embed UnimplementedMsgServer
+// for forward compatibility.
+//
+// Msg defines the staking Msg service.
+type MsgServer interface {
+	// CreateValidator defines a method for creating a new validator.
+	CreateValidator(context.Context, *MsgCreateValidator) (*MsgCreateValidatorResponse, error)
+	// EditValidator defines a method for editing an existing validator.
+	EditValidator(context.Context, *MsgEditValidator) (*MsgEditValidatorResponse, error)
+	// Delegate defines a method for performing a delegation of coins
+	// from a delegator to a validator.
+	Delegate(context.Context, *MsgDelegate) (*MsgDelegateResponse, error)
+	// BeginRedelegate defines a method for performing a redelegation
+	// of coins from a delegator and source validator to a destination validator.
+	BeginRedelegate(context.Context, *MsgBeginRedelegate) (*MsgBeginRedelegateResponse, error)
+	// Undelegate defines a method for performing an undelegation from a
+	// delegate and a validator.
+	Undelegate(context.Context, *MsgUndelegate) (*MsgUndelegateResponse, error)
+	// CancelUnbondingDelegation defines a method for performing canceling the unbonding delegation
+	// and delegate back to previous validator.
+	//
+	// Since: cosmos-sdk 0.46
+	CancelUnbondingDelegation(context.Context, *MsgCancelUnbondingDelegation) (*MsgCancelUnbondingDelegationResponse, error)
+	// UpdateParams defines an operation for updating the x/staking module
+	// parameters.
+	// Since: cosmos-sdk 0.47
+	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
+	mustEmbedUnimplementedMsgServer()
+}
+
+// UnimplementedMsgServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedMsgServer struct{}
+
+func (UnimplementedMsgServer) CreateValidator(context.Context, *MsgCreateValidator) (*MsgCreateValidatorResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreateValidator not implemented")
+}
+func (UnimplementedMsgServer) EditValidator(context.Context, *MsgEditValidator) (*MsgEditValidatorResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method EditValidator not implemented")
+}
+func (UnimplementedMsgServer) Delegate(context.Context, *MsgDelegate) (*MsgDelegateResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Delegate not implemented")
+}
+func (UnimplementedMsgServer) BeginRedelegate(context.Context, *MsgBeginRedelegate) (*MsgBeginRedelegateResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method BeginRedelegate not implemented")
+}
+func (UnimplementedMsgServer) Undelegate(context.Context, *MsgUndelegate) (*MsgUndelegateResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Undelegate not implemented")
+}
+func (UnimplementedMsgServer) CancelUnbondingDelegation(context.Context, *MsgCancelUnbondingDelegation) (*MsgCancelUnbondingDelegationResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CancelUnbondingDelegation not implemented")
+}
+func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
+}
+func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {}
+func (UnimplementedMsgServer) testEmbeddedByValue()             {}
+
+// UnsafeMsgServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to MsgServer will
+// result in compilation errors.
+type UnsafeMsgServer interface {
+	mustEmbedUnimplementedMsgServer()
+}
+
+func RegisterMsgServer(s grpc.ServiceRegistrar, srv MsgServer) {
+	// If the following call pancis, it indicates UnimplementedMsgServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&Msg_ServiceDesc, srv)
+}
+
+func _Msg_CreateValidator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgCreateValidator)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).CreateValidator(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Msg_CreateValidator_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).CreateValidator(ctx, req.(*MsgCreateValidator))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_EditValidator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgEditValidator)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).EditValidator(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Msg_EditValidator_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).EditValidator(ctx, req.(*MsgEditValidator))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_Delegate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgDelegate)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).Delegate(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Msg_Delegate_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).Delegate(ctx, req.(*MsgDelegate))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_BeginRedelegate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgBeginRedelegate)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).BeginRedelegate(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Msg_BeginRedelegate_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).BeginRedelegate(ctx, req.(*MsgBeginRedelegate))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_Undelegate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgUndelegate)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).Undelegate(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Msg_Undelegate_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).Undelegate(ctx, req.(*MsgUndelegate))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_CancelUnbondingDelegation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgCancelUnbondingDelegation)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).CancelUnbondingDelegation(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Msg_CancelUnbondingDelegation_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).CancelUnbondingDelegation(ctx, req.(*MsgCancelUnbondingDelegation))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgUpdateParams)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).UpdateParams(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Msg_UpdateParams_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Msg_ServiceDesc is the grpc.ServiceDesc for Msg service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Msg_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "cosmos.staking.v1beta1.Msg",
+	HandlerType: (*MsgServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CreateValidator",
+			Handler:    _Msg_CreateValidator_Handler,
+		},
+		{
+			MethodName: "EditValidator",
+			Handler:    _Msg_EditValidator_Handler,
+		},
+		{
+			MethodName: "Delegate",
+			Handler:    _Msg_Delegate_Handler,
+		},
+		{
+			MethodName: "BeginRedelegate",
+			Handler:    _Msg_BeginRedelegate_Handler,
+		},
+		{
+			MethodName: "Undelegate",
+			Handler:    _Msg_Undelegate_Handler,
+		},
+		{
+			MethodName: "CancelUnbondingDelegation",
+			Handler:    _Msg_CancelUnbondingDelegation_Handler,
+		},
+		{
+			MethodName: "UpdateParams",
+			Handler:    _Msg_UpdateParams_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "cosmos/staking/v1beta1/tx.proto",
+}
diff --git a/tests/integration/rapidgen/rapidgen.go b/tests/integration/rapidgen/rapidgen.go
index 64f494fe8cb1..3e331ee063e0 100644
--- a/tests/integration/rapidgen/rapidgen.go
+++ b/tests/integration/rapidgen/rapidgen.go
@@ -27,13 +27,13 @@ import (
 	mintapi "cosmossdk.io/api/cosmos/mint/v1beta1"
 	paramsapi "cosmossdk.io/api/cosmos/params/v1beta1"
 	slashingapi "cosmossdk.io/api/cosmos/slashing/v1beta1"
-	stakingapi "cosmossdk.io/api/cosmos/staking/v1beta1"
 	upgradeapi "cosmossdk.io/api/cosmos/upgrade/v1beta1"
 	vestingapi "cosmossdk.io/api/cosmos/vesting/v1beta1"
 	evidencetypes "cosmossdk.io/x/evidence/types"
 	feegranttypes "cosmossdk.io/x/feegrant"
 	upgradetypes "cosmossdk.io/x/upgrade/types"
 
+	stakingapi "github.com/cosmos/cosmos-sdk/atomone-api/cosmos/staking/v1beta1"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/multisig"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	vestingtypes "github.com/cosmos/cosmos-sdk/x/auth/vesting/types"
diff --git a/tests/integration/tx/aminojson/aminojson_test.go b/tests/integration/tx/aminojson/aminojson_test.go
index 4541e9eca680..a679ed43d698 100644
--- a/tests/integration/tx/aminojson/aminojson_test.go
+++ b/tests/integration/tx/aminojson/aminojson_test.go
@@ -29,16 +29,16 @@ import (
 	gov_v1beta1_api "cosmossdk.io/api/cosmos/gov/v1beta1"
 	msgv1 "cosmossdk.io/api/cosmos/msg/v1"
 	slashingapi "cosmossdk.io/api/cosmos/slashing/v1beta1"
-	stakingapi "cosmossdk.io/api/cosmos/staking/v1beta1"
 	txv1beta1 "cosmossdk.io/api/cosmos/tx/v1beta1"
 	vestingapi "cosmossdk.io/api/cosmos/vesting/v1beta1"
 	"cosmossdk.io/math"
 	"cosmossdk.io/x/evidence"
 	feegrantmodule "cosmossdk.io/x/feegrant/module"
-	"cosmossdk.io/x/tx/signing/aminojson"
+	"cosmossdk.io/x/tx/signing/aminojson"a
 	signing_testutil "cosmossdk.io/x/tx/signing/testutil"
 	"cosmossdk.io/x/upgrade"
 
+	stakingapi "github.com/cosmos/cosmos-sdk/atomone-api/cosmos/staking/v1beta1"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	ed25519types "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/multisig"
diff --git a/x/staking/autocli.go b/x/staking/autocli.go
index 7793049bae2e..dd18d5b780f3 100644
--- a/x/staking/autocli.go
+++ b/x/staking/autocli.go
@@ -5,8 +5,8 @@ import (
 
 	autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"
 	_ "cosmossdk.io/api/cosmos/crypto/ed25519" // register to that it shows up in protoregistry.GlobalTypes
-	stakingv1beta "cosmossdk.io/api/cosmos/staking/v1beta1"
 
+	stakingv1beta "github.com/cosmos/cosmos-sdk/atomone-api/cosmos/staking/v1beta1"
 	"github.com/cosmos/cosmos-sdk/version"
 )
 

From e5aaa3431ca6b0be3965a15ba61132386217328a Mon Sep 17 00:00:00 2001
From: Pantani <danpantani@gmail.com>
Date: Tue, 23 Sep 2025 04:18:01 -0300
Subject: [PATCH 9/9] remove typo

---
 tests/integration/tx/aminojson/aminojson_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/integration/tx/aminojson/aminojson_test.go b/tests/integration/tx/aminojson/aminojson_test.go
index a679ed43d698..005c703f899a 100644
--- a/tests/integration/tx/aminojson/aminojson_test.go
+++ b/tests/integration/tx/aminojson/aminojson_test.go
@@ -34,7 +34,7 @@ import (
 	"cosmossdk.io/math"
 	"cosmossdk.io/x/evidence"
 	feegrantmodule "cosmossdk.io/x/feegrant/module"
-	"cosmossdk.io/x/tx/signing/aminojson"a
+	"cosmossdk.io/x/tx/signing/aminojson"
 	signing_testutil "cosmossdk.io/x/tx/signing/testutil"
 	"cosmossdk.io/x/upgrade"