github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/staking/typesadapter/staking.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: cosmos/staking/v1beta1/staking.proto

package typesadapter

import (
	bytes "bytes"
	compress_gzip "compress/gzip"
	fmt "fmt"
	io "io"
	io_ioutil "io/ioutil"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
	time "time"

	"github.com/fibonacci-chain/fbc/libs/tendermint/abci/types"

	github_com_cosmos_cosmos_sdk_types "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"

	types1 "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/codec/types"

	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/gogo/protobuf/gogoproto"
	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "google.golang.org/protobuf/types/known/durationpb"
	_ "google.golang.org/protobuf/types/known/timestamppb"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// BondStatus is the status of a validator.
type BondStatus int32

const (
	// UNSPECIFIED defines an invalid validator status.
	Unspecified BondStatus = 0
	// UNBONDED defines a validator that is not bonded.
	Unbonded BondStatus = 1
	// UNBONDING defines a validator that is unbonding.
	Unbonding BondStatus = 2
	// BONDED defines a validator that is bonded.
	Bonded BondStatus = 3
)

var BondStatus_name = map[int32]string{
	0: "BOND_STATUS_UNSPECIFIED",
	1: "BOND_STATUS_UNBONDED",
	2: "BOND_STATUS_UNBONDING",
	3: "BOND_STATUS_BONDED",
}

var BondStatus_value = map[string]int32{
	"BOND_STATUS_UNSPECIFIED": 0,
	"BOND_STATUS_UNBONDED":    1,
	"BOND_STATUS_UNBONDING":   2,
	"BOND_STATUS_BONDED":      3,
}

func (x BondStatus) String() string {
	return proto.EnumName(BondStatus_name, int32(x))
}

func (BondStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{0}
}

// 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 {
	Header types.Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header"`
	Valset []Validator  `protobuf:"bytes,2,rep,name=valset,proto3" json:"valset"`
}

func (m *HistoricalInfo) Reset()         { *m = HistoricalInfo{} }
func (m *HistoricalInfo) String() string { return proto.CompactTextString(m) }
func (*HistoricalInfo) ProtoMessage()    {}
func (*HistoricalInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{0}
}
func (m *HistoricalInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HistoricalInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HistoricalInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HistoricalInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HistoricalInfo.Merge(m, src)
}
func (m *HistoricalInfo) XXX_Size() int {
	return m.Size()
}
func (m *HistoricalInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_HistoricalInfo.DiscardUnknown(m)
}

var xxx_messageInfo_HistoricalInfo proto.InternalMessageInfo

func (m *HistoricalInfo) GetHeader() types.Header {
	if m != nil {
		return m.Header
	}
	return types.Header{}
}

func (m *HistoricalInfo) GetValset() []Validator {
	if m != nil {
		return m.Valset
	}
	return nil
}

// CommissionRates defines the initial commission rates to be used for creating
// a validator.
type CommissionRates struct {
	// rate is the commission rate charged to delegators, as a fraction.
	Rate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=rate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"rate"`
	// max_rate defines the maximum commission rate which validator can ever charge, as a fraction.
	MaxRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=max_rate,json=maxRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_rate"`
	// max_change_rate defines the maximum daily increase of the validator commission, as a fraction.
	MaxChangeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=max_change_rate,json=maxChangeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_change_rate"`
}

func (m *CommissionRates) Reset()      { *m = CommissionRates{} }
func (*CommissionRates) ProtoMessage() {}
func (*CommissionRates) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{1}
}
func (m *CommissionRates) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CommissionRates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CommissionRates.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CommissionRates) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommissionRates.Merge(m, src)
}
func (m *CommissionRates) XXX_Size() int {
	return m.Size()
}
func (m *CommissionRates) XXX_DiscardUnknown() {
	xxx_messageInfo_CommissionRates.DiscardUnknown(m)
}

var xxx_messageInfo_CommissionRates proto.InternalMessageInfo

// Commission defines commission parameters for a given validator.
type Commission struct {
	// commission_rates defines the initial commission rates to be used for creating a validator.
	CommissionRates `protobuf:"bytes,1,opt,name=commission_rates,json=commissionRates,proto3,embedded=commission_rates" json:"commission_rates"`
	// update_time is the last time the commission rate was changed.
	UpdateTime time.Time `protobuf:"bytes,2,opt,name=update_time,json=updateTime,proto3,stdtime" json:"update_time"`
}

func (m *Commission) Reset()      { *m = Commission{} }
func (*Commission) ProtoMessage() {}
func (*Commission) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{2}
}
func (m *Commission) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Commission) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Commission.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Commission) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Commission.Merge(m, src)
}
func (m *Commission) XXX_Size() int {
	return m.Size()
}
func (m *Commission) XXX_DiscardUnknown() {
	xxx_messageInfo_Commission.DiscardUnknown(m)
}

var xxx_messageInfo_Commission proto.InternalMessageInfo

func (m *Commission) GetUpdateTime() time.Time {
	if m != nil {
		return m.UpdateTime
	}
	return time.Time{}
}

// Description defines a validator description.
type Description struct {
	// 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 (m *Description) Reset()      { *m = Description{} }
func (*Description) ProtoMessage() {}
func (*Description) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{3}
}
func (m *Description) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Description) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Description.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Description) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Description.Merge(m, src)
}
func (m *Description) XXX_Size() int {
	return m.Size()
}
func (m *Description) XXX_DiscardUnknown() {
	xxx_messageInfo_Description.DiscardUnknown(m)
}

var xxx_messageInfo_Description proto.InternalMessageInfo

func (m *Description) GetMoniker() string {
	if m != nil {
		return m.Moniker
	}
	return ""
}

func (m *Description) GetIdentity() string {
	if m != nil {
		return m.Identity
	}
	return ""
}

func (m *Description) GetWebsite() string {
	if m != nil {
		return m.Website
	}
	return ""
}

func (m *Description) GetSecurityContact() string {
	if m != nil {
		return m.SecurityContact
	}
	return ""
}

func (m *Description) GetDetails() string {
	if m != nil {
		return m.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 {
	// 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 *types1.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 github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=tokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"tokens"`
	// delegator_shares defines total shares issued to a validator's delegators.
	DelegatorShares github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=delegator_shares,json=delegatorShares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"delegator_shares"`
	// description defines the description terms for the validator.
	Description Description `protobuf:"bytes,7,opt,name=description,proto3" json:"description"`
	// 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 time.Time `protobuf:"bytes,9,opt,name=unbonding_time,json=unbondingTime,proto3,stdtime" json:"unbonding_time"`
	// commission defines the commission parameters.
	Commission Commission `protobuf:"bytes,10,opt,name=commission,proto3" json:"commission"`
	// min_self_delegation is the validator's self declared minimum self delegation.
	//
	// Since: cosmos-sdk 0.46
	MinSelfDelegation github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,11,opt,name=min_self_delegation,json=minSelfDelegation,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_self_delegation"`
}

func (m *Validator) Reset()      { *m = Validator{} }
func (*Validator) ProtoMessage() {}
func (*Validator) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{4}
}
func (m *Validator) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Validator.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Validator) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Validator.Merge(m, src)
}
func (m *Validator) XXX_Size() int {
	return m.Size()
}
func (m *Validator) XXX_DiscardUnknown() {
	xxx_messageInfo_Validator.DiscardUnknown(m)
}

var xxx_messageInfo_Validator proto.InternalMessageInfo

// ValAddresses defines a repeated set of validator addresses.
type ValAddresses struct {
	Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
}

func (m *ValAddresses) Reset()      { *m = ValAddresses{} }
func (*ValAddresses) ProtoMessage() {}
func (*ValAddresses) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{5}
}
func (m *ValAddresses) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValAddresses) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValAddresses.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValAddresses) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValAddresses.Merge(m, src)
}
func (m *ValAddresses) XXX_Size() int {
	return m.Size()
}
func (m *ValAddresses) XXX_DiscardUnknown() {
	xxx_messageInfo_ValAddresses.DiscardUnknown(m)
}

var xxx_messageInfo_ValAddresses proto.InternalMessageInfo

func (m *ValAddresses) GetAddresses() []string {
	if m != nil {
		return m.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 {
	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 (m *DVPair) Reset()      { *m = DVPair{} }
func (*DVPair) ProtoMessage() {}
func (*DVPair) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{6}
}
func (m *DVPair) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DVPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DVPair.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DVPair) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DVPair.Merge(m, src)
}
func (m *DVPair) XXX_Size() int {
	return m.Size()
}
func (m *DVPair) XXX_DiscardUnknown() {
	xxx_messageInfo_DVPair.DiscardUnknown(m)
}

var xxx_messageInfo_DVPair proto.InternalMessageInfo

// DVPairs defines an array of DVPair objects.
type DVPairs struct {
	Pairs []DVPair `protobuf:"bytes,1,rep,name=pairs,proto3" json:"pairs"`
}

func (m *DVPairs) Reset()         { *m = DVPairs{} }
func (m *DVPairs) String() string { return proto.CompactTextString(m) }
func (*DVPairs) ProtoMessage()    {}
func (*DVPairs) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{7}
}
func (m *DVPairs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DVPairs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DVPairs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DVPairs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DVPairs.Merge(m, src)
}
func (m *DVPairs) XXX_Size() int {
	return m.Size()
}
func (m *DVPairs) XXX_DiscardUnknown() {
	xxx_messageInfo_DVPairs.DiscardUnknown(m)
}

var xxx_messageInfo_DVPairs proto.InternalMessageInfo

func (m *DVPairs) GetPairs() []DVPair {
	if m != nil {
		return m.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 {
	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 (m *DVVTriplet) Reset()      { *m = DVVTriplet{} }
func (*DVVTriplet) ProtoMessage() {}
func (*DVVTriplet) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{8}
}
func (m *DVVTriplet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DVVTriplet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DVVTriplet.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DVVTriplet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DVVTriplet.Merge(m, src)
}
func (m *DVVTriplet) XXX_Size() int {
	return m.Size()
}
func (m *DVVTriplet) XXX_DiscardUnknown() {
	xxx_messageInfo_DVVTriplet.DiscardUnknown(m)
}

var xxx_messageInfo_DVVTriplet proto.InternalMessageInfo

// DVVTriplets defines an array of DVVTriplet objects.
type DVVTriplets struct {
	Triplets []DVVTriplet `protobuf:"bytes,1,rep,name=triplets,proto3" json:"triplets"`
}

func (m *DVVTriplets) Reset()         { *m = DVVTriplets{} }
func (m *DVVTriplets) String() string { return proto.CompactTextString(m) }
func (*DVVTriplets) ProtoMessage()    {}
func (*DVVTriplets) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{9}
}
func (m *DVVTriplets) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DVVTriplets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DVVTriplets.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DVVTriplets) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DVVTriplets.Merge(m, src)
}
func (m *DVVTriplets) XXX_Size() int {
	return m.Size()
}
func (m *DVVTriplets) XXX_DiscardUnknown() {
	xxx_messageInfo_DVVTriplets.DiscardUnknown(m)
}

var xxx_messageInfo_DVVTriplets proto.InternalMessageInfo

func (m *DVVTriplets) GetTriplets() []DVVTriplet {
	if m != nil {
		return m.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 {
	// 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_address is the bech32-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 github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=shares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares"`
}

func (m *Delegation) Reset()      { *m = Delegation{} }
func (*Delegation) ProtoMessage() {}
func (*Delegation) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{10}
}
func (m *Delegation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Delegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Delegation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Delegation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Delegation.Merge(m, src)
}
func (m *Delegation) XXX_Size() int {
	return m.Size()
}
func (m *Delegation) XXX_DiscardUnknown() {
	xxx_messageInfo_Delegation.DiscardUnknown(m)
}

var xxx_messageInfo_Delegation proto.InternalMessageInfo

// UnbondingDelegation stores all of a single delegator's unbonding bonds
// for a single validator in an time-ordered list.
type UnbondingDelegation struct {
	// 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_address is the bech32-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"`
}

func (m *UnbondingDelegation) Reset()      { *m = UnbondingDelegation{} }
func (*UnbondingDelegation) ProtoMessage() {}
func (*UnbondingDelegation) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{11}
}
func (m *UnbondingDelegation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnbondingDelegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnbondingDelegation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnbondingDelegation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnbondingDelegation.Merge(m, src)
}
func (m *UnbondingDelegation) XXX_Size() int {
	return m.Size()
}
func (m *UnbondingDelegation) XXX_DiscardUnknown() {
	xxx_messageInfo_UnbondingDelegation.DiscardUnknown(m)
}

var xxx_messageInfo_UnbondingDelegation proto.InternalMessageInfo

// UnbondingDelegationEntry defines an unbonding object with relevant metadata.
type UnbondingDelegationEntry struct {
	// 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 time.Time `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time"`
	// initial_balance defines the tokens initially scheduled to receive at completion.
	InitialBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance"`
	// balance defines the tokens to receive at completion.
	Balance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"`
}

func (m *UnbondingDelegationEntry) Reset()      { *m = UnbondingDelegationEntry{} }
func (*UnbondingDelegationEntry) ProtoMessage() {}
func (*UnbondingDelegationEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{12}
}
func (m *UnbondingDelegationEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnbondingDelegationEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnbondingDelegationEntry.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnbondingDelegationEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnbondingDelegationEntry.Merge(m, src)
}
func (m *UnbondingDelegationEntry) XXX_Size() int {
	return m.Size()
}
func (m *UnbondingDelegationEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_UnbondingDelegationEntry.DiscardUnknown(m)
}

var xxx_messageInfo_UnbondingDelegationEntry proto.InternalMessageInfo

func (m *UnbondingDelegationEntry) GetCreationHeight() int64 {
	if m != nil {
		return m.CreationHeight
	}
	return 0
}

func (m *UnbondingDelegationEntry) GetCompletionTime() time.Time {
	if m != nil {
		return m.CompletionTime
	}
	return time.Time{}
}

// RedelegationEntry defines a redelegation object with relevant metadata.
type RedelegationEntry struct {
	// 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 time.Time `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time"`
	// initial_balance defines the initial balance when redelegation started.
	InitialBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance"`
	// shares_dst is the amount of destination-validator shares created by redelegation.
	SharesDst github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=shares_dst,json=sharesDst,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares_dst"`
}

func (m *RedelegationEntry) Reset()      { *m = RedelegationEntry{} }
func (*RedelegationEntry) ProtoMessage() {}
func (*RedelegationEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{13}
}
func (m *RedelegationEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RedelegationEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RedelegationEntry.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RedelegationEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RedelegationEntry.Merge(m, src)
}
func (m *RedelegationEntry) XXX_Size() int {
	return m.Size()
}
func (m *RedelegationEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_RedelegationEntry.DiscardUnknown(m)
}

var xxx_messageInfo_RedelegationEntry proto.InternalMessageInfo

func (m *RedelegationEntry) GetCreationHeight() int64 {
	if m != nil {
		return m.CreationHeight
	}
	return 0
}

func (m *RedelegationEntry) GetCompletionTime() time.Time {
	if m != nil {
		return m.CompletionTime
	}
	return time.Time{}
}

// Redelegation contains the list of a particular delegator's redelegating bonds
// from a particular source validator to a particular destination validator.
type Redelegation struct {
	// 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"`
}

func (m *Redelegation) Reset()      { *m = Redelegation{} }
func (*Redelegation) ProtoMessage() {}
func (*Redelegation) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{14}
}
func (m *Redelegation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Redelegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Redelegation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Redelegation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Redelegation.Merge(m, src)
}
func (m *Redelegation) XXX_Size() int {
	return m.Size()
}
func (m *Redelegation) XXX_DiscardUnknown() {
	xxx_messageInfo_Redelegation.DiscardUnknown(m)
}

var xxx_messageInfo_Redelegation proto.InternalMessageInfo

// Params defines the parameters for the staking module.
type Params struct {
	// unbonding_time is the time duration of unbonding.
	UnbondingTime time.Duration `protobuf:"bytes,1,opt,name=unbonding_time,json=unbondingTime,proto3,stdduration" json:"unbonding_time"`
	// 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 is the chain-wide minimum commission rate that a validator can charge their delegators
	MinCommissionRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=min_commission_rate,json=minCommissionRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"min_commission_rate" yaml:"min_commission_rate"`
}

func (m *Params) Reset()      { *m = Params{} }
func (*Params) ProtoMessage() {}
func (*Params) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{15}
}
func (m *Params) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Params.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Params) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Params.Merge(m, src)
}
func (m *Params) XXX_Size() int {
	return m.Size()
}
func (m *Params) XXX_DiscardUnknown() {
	xxx_messageInfo_Params.DiscardUnknown(m)
}

var xxx_messageInfo_Params proto.InternalMessageInfo

func (m *Params) GetUnbondingTime() time.Duration {
	if m != nil {
		return m.UnbondingTime
	}
	return 0
}

func (m *Params) GetMaxValidators() uint32 {
	if m != nil {
		return m.MaxValidators
	}
	return 0
}

func (m *Params) GetMaxEntries() uint32 {
	if m != nil {
		return m.MaxEntries
	}
	return 0
}

func (m *Params) GetHistoricalEntries() uint32 {
	if m != nil {
		return m.HistoricalEntries
	}
	return 0
}

func (m *Params) GetBondDenom() string {
	if m != nil {
		return m.BondDenom
	}
	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 {
	Delegation Delegation                                     `protobuf:"bytes,1,opt,name=delegation,proto3" json:"delegation"`
	Balance    github_com_cosmos_cosmos_sdk_types.CoinAdapter `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance"`
}

func (m *DelegationResponse) Reset()      { *m = DelegationResponse{} }
func (*DelegationResponse) ProtoMessage() {}
func (*DelegationResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{16}
}
func (m *DelegationResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DelegationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DelegationResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DelegationResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DelegationResponse.Merge(m, src)
}
func (m *DelegationResponse) XXX_Size() int {
	return m.Size()
}
func (m *DelegationResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DelegationResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DelegationResponse proto.InternalMessageInfo

func (m *DelegationResponse) GetDelegation() Delegation {
	if m != nil {
		return m.Delegation
	}
	return Delegation{}
}

func (m *DelegationResponse) GetBalance() github_com_cosmos_cosmos_sdk_types.CoinAdapter {
	if m != nil {
		return m.Balance
	}
	return github_com_cosmos_cosmos_sdk_types.CoinAdapter{}
}

// 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 {
	RedelegationEntry RedelegationEntry                      `protobuf:"bytes,1,opt,name=redelegation_entry,json=redelegationEntry,proto3" json:"redelegation_entry"`
	Balance           github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"`
}

func (m *RedelegationEntryResponse) Reset()         { *m = RedelegationEntryResponse{} }
func (m *RedelegationEntryResponse) String() string { return proto.CompactTextString(m) }
func (*RedelegationEntryResponse) ProtoMessage()    {}
func (*RedelegationEntryResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{17}
}
func (m *RedelegationEntryResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RedelegationEntryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RedelegationEntryResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RedelegationEntryResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RedelegationEntryResponse.Merge(m, src)
}
func (m *RedelegationEntryResponse) XXX_Size() int {
	return m.Size()
}
func (m *RedelegationEntryResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RedelegationEntryResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RedelegationEntryResponse proto.InternalMessageInfo

func (m *RedelegationEntryResponse) GetRedelegationEntry() RedelegationEntry {
	if m != nil {
		return m.RedelegationEntry
	}
	return RedelegationEntry{}
}

// 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 {
	Redelegation Redelegation                `protobuf:"bytes,1,opt,name=redelegation,proto3" json:"redelegation"`
	Entries      []RedelegationEntryResponse `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries"`
}

func (m *RedelegationResponse) Reset()         { *m = RedelegationResponse{} }
func (m *RedelegationResponse) String() string { return proto.CompactTextString(m) }
func (*RedelegationResponse) ProtoMessage()    {}
func (*RedelegationResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{18}
}
func (m *RedelegationResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RedelegationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RedelegationResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RedelegationResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RedelegationResponse.Merge(m, src)
}
func (m *RedelegationResponse) XXX_Size() int {
	return m.Size()
}
func (m *RedelegationResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RedelegationResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RedelegationResponse proto.InternalMessageInfo

func (m *RedelegationResponse) GetRedelegation() Redelegation {
	if m != nil {
		return m.Redelegation
	}
	return Redelegation{}
}

func (m *RedelegationResponse) GetEntries() []RedelegationEntryResponse {
	if m != nil {
		return m.Entries
	}
	return nil
}

// Pool is used for tracking bonded and not-bonded token supply of the bond
// denomination.
type Pool struct {
	NotBondedTokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=not_bonded_tokens,json=notBondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"not_bonded_tokens"`
	BondedTokens    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=bonded_tokens,json=bondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonded_tokens"`
}

func (m *Pool) Reset()         { *m = Pool{} }
func (m *Pool) String() string { return proto.CompactTextString(m) }
func (*Pool) ProtoMessage()    {}
func (*Pool) Descriptor() ([]byte, []int) {
	return fileDescriptor_64c30c6cf92913c9, []int{19}
}
func (m *Pool) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Pool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Pool.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Pool) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Pool.Merge(m, src)
}
func (m *Pool) XXX_Size() int {
	return m.Size()
}
func (m *Pool) XXX_DiscardUnknown() {
	xxx_messageInfo_Pool.DiscardUnknown(m)
}

var xxx_messageInfo_Pool proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("cosmos.staking.v1beta1.BondStatus", BondStatus_name, BondStatus_value)
	proto.RegisterType((*HistoricalInfo)(nil), "cosmos.staking.v1beta1.HistoricalInfo")
	proto.RegisterType((*CommissionRates)(nil), "cosmos.staking.v1beta1.CommissionRates")
	proto.RegisterType((*Commission)(nil), "cosmos.staking.v1beta1.Commission")
	proto.RegisterType((*Description)(nil), "cosmos.staking.v1beta1.Description")
	proto.RegisterType((*Validator)(nil), "cosmos.staking.v1beta1.Validator")
	proto.RegisterType((*ValAddresses)(nil), "cosmos.staking.v1beta1.ValAddresses")
	proto.RegisterType((*DVPair)(nil), "cosmos.staking.v1beta1.DVPair")
	proto.RegisterType((*DVPairs)(nil), "cosmos.staking.v1beta1.DVPairs")
	proto.RegisterType((*DVVTriplet)(nil), "cosmos.staking.v1beta1.DVVTriplet")
	proto.RegisterType((*DVVTriplets)(nil), "cosmos.staking.v1beta1.DVVTriplets")
	proto.RegisterType((*Delegation)(nil), "cosmos.staking.v1beta1.Delegation")
	proto.RegisterType((*UnbondingDelegation)(nil), "cosmos.staking.v1beta1.UnbondingDelegation")
	proto.RegisterType((*UnbondingDelegationEntry)(nil), "cosmos.staking.v1beta1.UnbondingDelegationEntry")
	proto.RegisterType((*RedelegationEntry)(nil), "cosmos.staking.v1beta1.RedelegationEntry")
	proto.RegisterType((*Redelegation)(nil), "cosmos.staking.v1beta1.Redelegation")
	proto.RegisterType((*Params)(nil), "cosmos.staking.v1beta1.Params")
	proto.RegisterType((*DelegationResponse)(nil), "cosmos.staking.v1beta1.DelegationResponse")
	proto.RegisterType((*RedelegationEntryResponse)(nil), "cosmos.staking.v1beta1.RedelegationEntryResponse")
	proto.RegisterType((*RedelegationResponse)(nil), "cosmos.staking.v1beta1.RedelegationResponse")
	proto.RegisterType((*Pool)(nil), "cosmos.staking.v1beta1.Pool")
}

func init() {
	proto.RegisterFile("cosmos/staking/v1beta1/staking.proto", fileDescriptor_64c30c6cf92913c9)
}

var fileDescriptor_64c30c6cf92913c9 = []byte{
	// 1669 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0x4d, 0x6c, 0x1b, 0xc7,
	0x15, 0xe6, 0x52, 0x0c, 0x45, 0x3d, 0x4a, 0xa2, 0x34, 0x56, 0x52, 0x9a, 0x68, 0x49, 0x96, 0x4d,
	0x13, 0xa7, 0x88, 0xa9, 0x5a, 0x05, 0x02, 0x54, 0x28, 0x50, 0x98, 0x22, 0x53, 0xab, 0x4e, 0x5c,
	0x86, 0x94, 0x55, 0xf4, 0x07, 0x5d, 0x0c, 0x77, 0x47, 0xd4, 0x54, 0xbb, 0xb3, 0xc4, 0xce, 0xd0,
	0x15, 0x81, 0x16, 0x28, 0xd0, 0x4b, 0xea, 0x53, 0x8e, 0xb9, 0x18, 0x30, 0x90, 0x1e, 0x73, 0x0c,
	0x7a, 0xe9, 0xa1, 0xd7, 0x34, 0x27, 0x23, 0xa7, 0xa6, 0x2d, 0xd4, 0xc2, 0xbe, 0x14, 0x3d, 0x15,
	0xb9, 0xb7, 0x28, 0xe6, 0x67, 0x7f, 0x4c, 0x8a, 0x8a, 0x14, 0xa8, 0x40, 0x00, 0x5f, 0xec, 0x9d,
	0x99, 0xf7, 0xbe, 0x79, 0xef, 0x7b, 0x3f, 0x7a, 0x43, 0x78, 0xd1, 0x09, 0xb8, 0x1f, 0xf0, 0x4d,
	0x2e, 0xf0, 0x11, 0x65, 0xc3, 0xcd, 0x7b, 0x37, 0x06, 0x44, 0xe0, 0x1b, 0xd1, 0xba, 0x39, 0x0a,
	0x03, 0x11, 0xa0, 0x17, 0xb4, 0x54, 0x33, 0xda, 0x35, 0x52, 0x95, 0x8d, 0x61, 0x30, 0x0c, 0x94,
	0xc8, 0xa6, 0xfc, 0xd2, 0xd2, 0x95, 0xab, 0xc3, 0x20, 0x18, 0x7a, 0x64, 0x53, 0xad, 0x06, 0xe3,
	0x83, 0x4d, 0xcc, 0x26, 0xe6, 0xa8, 0x3a, 0x7d, 0xe4, 0x8e, 0x43, 0x2c, 0x68, 0xc0, 0xcc, 0x79,
	0x6d, 0xfa, 0x5c, 0x50, 0x9f, 0x70, 0x81, 0xfd, 0x51, 0x84, 0xad, 0x2d, 0xb1, 0xf5, 0xa5, 0xc6,
	0x2c, 0x83, 0x6d, 0x5c, 0x19, 0x60, 0x4e, 0x62, 0x3f, 0x9c, 0x80, 0x46, 0xd8, 0x5f, 0x16, 0x84,
	0xb9, 0x24, 0xf4, 0x29, 0x13, 0x9b, 0x62, 0x32, 0x22, 0x5c, 0xff, 0xab, 0x4f, 0x1b, 0xbf, 0xb5,
	0x60, 0xf5, 0x16, 0xe5, 0x22, 0x08, 0xa9, 0x83, 0xbd, 0x5d, 0x76, 0x10, 0xa0, 0xd7, 0x20, 0x7f,
	0x48, 0xb0, 0x4b, 0xc2, 0xb2, 0x55, 0xb7, 0xae, 0x15, 0xb7, 0xca, 0xcd, 0x04, 0xa1, 0xa9, 0x75,
	0x6f, 0xa9, 0xf3, 0x56, 0xee, 0xc3, 0x93, 0x5a, 0xa6, 0x67, 0xa4, 0xd1, 0x77, 0x21, 0x7f, 0x0f,
	0x7b, 0x9c, 0x88, 0x72, 0xb6, 0xbe, 0x70, 0xad, 0xb8, 0xf5, 0xd5, 0xe6, 0xe9, 0xf4, 0x35, 0xf7,
	0xb1, 0x47, 0x5d, 0x2c, 0x82, 0x18, 0x40, 0xab, 0x35, 0xde, 0xcf, 0x42, 0x69, 0x27, 0xf0, 0x7d,
	0xca, 0x39, 0x0d, 0x58, 0x0f, 0x0b, 0xc2, 0x51, 0x17, 0x72, 0x21, 0x16, 0x44, 0x99, 0xb2, 0xd4,
	0xfa, 0x8e, 0x94, 0xff, 0xcb, 0x49, 0xed, 0xa5, 0x21, 0x15, 0x87, 0xe3, 0x41, 0xd3, 0x09, 0x7c,
	0x43, 0x86, 0xf9, 0xef, 0x3a, 0x77, 0x8f, 0x8c, 0x7f, 0x6d, 0xe2, 0x7c, 0xfc, 0xc1, 0x75, 0x30,
	0x36, 0xb4, 0x89, 0xd3, 0x53, 0x48, 0xe8, 0x87, 0x50, 0xf0, 0xf1, 0xb1, 0xad, 0x50, 0xb3, 0x97,
	0x80, 0xba, 0xe8, 0xe3, 0x63, 0x69, 0x2b, 0x72, 0xa1, 0x24, 0x81, 0x9d, 0x43, 0xcc, 0x86, 0x44,
	0xe3, 0x2f, 0x5c, 0x02, 0xfe, 0x8a, 0x8f, 0x8f, 0x77, 0x14, 0xa6, 0xbc, 0x65, 0xbb, 0xf0, 0xee,
	0xc3, 0x5a, 0xe6, 0x9f, 0x0f, 0x6b, 0x56, 0xe3, 0x0f, 0x16, 0x40, 0x42, 0x17, 0xfa, 0x29, 0xac,
	0x39, 0xf1, 0x4a, 0x5d, 0xcf, 0x4d, 0x00, 0x5f, 0x9e, 0x17, 0x88, 0x29, 0xb2, 0x5b, 0x05, 0x69,
	0xe8, 0xa3, 0x93, 0x9a, 0xd5, 0x2b, 0x39, 0x53, 0x71, 0xe8, 0x40, 0x71, 0x3c, 0x72, 0xb1, 0x20,
	0xb6, 0x4c, 0x4d, 0x45, 0x5c, 0x71, 0xab, 0xd2, 0xd4, 0x79, 0xdb, 0x8c, 0xf2, 0xb6, 0xb9, 0x17,
	0xe5, 0xad, 0xc6, 0x7a, 0xe7, 0xef, 0x35, 0xab, 0x07, 0x5a, 0x51, 0x1e, 0xa5, 0xac, 0x7f, 0xdf,
	0x82, 0x62, 0x9b, 0x70, 0x27, 0xa4, 0x23, 0x59, 0x08, 0xa8, 0x0c, 0x8b, 0x7e, 0xc0, 0xe8, 0x91,
	0x49, 0xbb, 0xa5, 0x5e, 0xb4, 0x44, 0x15, 0x28, 0x50, 0x97, 0x30, 0x41, 0xc5, 0x44, 0x07, 0xac,
	0x17, 0xaf, 0xa5, 0xd6, 0x2f, 0xc8, 0x80, 0xd3, 0x88, 0xeb, 0x5e, 0xb4, 0x44, 0xaf, 0xc0, 0x1a,
	0x27, 0xce, 0x38, 0xa4, 0x62, 0x62, 0x3b, 0x01, 0x13, 0xd8, 0x11, 0xe5, 0x9c, 0x12, 0x29, 0x45,
	0xfb, 0x3b, 0x7a, 0x5b, 0x82, 0xb8, 0x44, 0x60, 0xea, 0xf1, 0xf2, 0x73, 0x1a, 0xc4, 0x2c, 0x53,
	0xe6, 0xfe, 0x29, 0x0f, 0x4b, 0x71, 0xde, 0xa2, 0x1d, 0x58, 0x0b, 0x46, 0x24, 0x94, 0xdf, 0x36,
	0x76, 0xdd, 0x90, 0x70, 0x6e, 0x32, 0xb4, 0xfc, 0xf1, 0x07, 0xd7, 0x37, 0x0c, 0xdd, 0x37, 0xf5,
	0x49, 0x5f, 0x84, 0x94, 0x0d, 0x7b, 0xa5, 0x48, 0xc3, 0x6c, 0xa3, 0x1f, 0xc9, 0x80, 0x31, 0x4e,
	0x18, 0x1f, 0x73, 0x7b, 0x34, 0x1e, 0x1c, 0x91, 0x89, 0xe1, 0x75, 0x63, 0x86, 0xd7, 0x9b, 0x6c,
	0xd2, 0x2a, 0x7f, 0x94, 0x40, 0x3b, 0xe1, 0x64, 0x24, 0x82, 0x66, 0x77, 0x3c, 0xb8, 0x4d, 0x26,
	0x32, 0x5a, 0x06, 0xa7, 0xab, 0x60, 0xd0, 0x0b, 0x90, 0xff, 0x39, 0xa6, 0x1e, 0x71, 0x15, 0x2b,
	0x85, 0x9e, 0x59, 0xa1, 0x6d, 0xc8, 0x73, 0x81, 0xc5, 0x98, 0x2b, 0x2a, 0x56, 0xb7, 0x1a, 0xf3,
	0x32, 0xa3, 0x15, 0x30, 0xb7, 0xaf, 0x24, 0x7b, 0x46, 0x03, 0xed, 0x41, 0x5e, 0x04, 0x47, 0x84,
	0x19, 0x92, 0x2e, 0x94, 0xd5, 0xbb, 0x4c, 0xa4, 0xb2, 0x7a, 0x97, 0x89, 0x9e, 0xc1, 0x42, 0x43,
	0x58, 0x73, 0x89, 0x47, 0x86, 0x8a, 0x4a, 0x7e, 0x88, 0x43, 0xc2, 0xcb, 0xf9, 0x4b, 0xa8, 0x9a,
	0x52, 0x8c, 0xda, 0x57, 0xa0, 0xe8, 0x36, 0x14, 0xdd, 0x24, 0xdd, 0xca, 0x8b, 0x8a, 0xe8, 0xaf,
	0xcd, 0xf3, 0x3f, 0x95, 0x99, 0xa6, 0x49, 0xa5, 0xb5, 0x65, 0x72, 0x8d, 0xd9, 0x20, 0x60, 0x2e,
	0x65, 0x43, 0xfb, 0x90, 0xd0, 0xe1, 0xa1, 0x28, 0x17, 0xea, 0xd6, 0xb5, 0x85, 0x5e, 0x29, 0xde,
	0xbf, 0xa5, 0xb6, 0xd1, 0x6d, 0x58, 0x4d, 0x44, 0x55, 0xed, 0x2c, 0x5d, 0xa0, 0x76, 0x56, 0x62,
	0x5d, 0x79, 0x8a, 0x6e, 0x01, 0x24, 0x85, 0x59, 0x06, 0x05, 0xd4, 0xf8, 0xec, 0xea, 0x36, 0x2e,
	0xa4, 0x74, 0x91, 0x07, 0x57, 0x7c, 0xca, 0x6c, 0x4e, 0xbc, 0x03, 0xdb, 0x50, 0x25, 0x21, 0x8b,
	0x97, 0x10, 0xda, 0x75, 0x9f, 0xb2, 0x3e, 0xf1, 0x0e, 0xda, 0x31, 0xec, 0xf6, 0xf2, 0xdb, 0x0f,
	0x6b, 0x19, 0x53, 0x4b, 0x99, 0x46, 0x17, 0x96, 0xf7, 0xb1, 0x67, 0xca, 0x80, 0x70, 0xf4, 0x1a,
	0x2c, 0xe1, 0x68, 0x51, 0xb6, 0xea, 0x0b, 0x67, 0x96, 0x51, 0x22, 0xaa, 0xab, 0xf3, 0xd7, 0x7f,
	0xab, 0x5b, 0x8d, 0xdf, 0x59, 0x90, 0x6f, 0xef, 0x77, 0x31, 0x0d, 0x51, 0x07, 0xd6, 0x93, 0x84,
	0x3a, 0x6f, 0x6d, 0x26, 0x39, 0x18, 0x15, 0x67, 0x07, 0xd6, 0xef, 0x45, 0xe5, 0x1e, 0xc3, 0x64,
	0x3f, 0x0b, 0x26, 0x56, 0x31, 0xfb, 0x53, 0x8e, 0x77, 0x60, 0x51, 0x5b, 0xc9, 0xd1, 0x36, 0x3c,
	0x37, 0x92, 0x1f, 0xca, 0xdf, 0xe2, 0x56, 0x75, 0x6e, 0x22, 0x2a, 0x79, 0x13, 0x40, 0xad, 0xd2,
	0xf8, 0x8f, 0x05, 0xd0, 0xde, 0xdf, 0xdf, 0x0b, 0xe9, 0xc8, 0x23, 0xe2, 0xb2, 0x3c, 0x7e, 0x03,
	0x9e, 0x4f, 0x3c, 0xe6, 0xa1, 0x73, 0x6e, 0xaf, 0xaf, 0xc4, 0x6a, 0xfd, 0xd0, 0x39, 0x15, 0xcd,
	0xe5, 0x22, 0x46, 0x5b, 0x38, 0x37, 0x5a, 0x9b, 0x8b, 0xd3, 0x69, 0xec, 0x43, 0x31, 0x71, 0x9f,
	0xa3, 0x36, 0x14, 0x84, 0xf9, 0x36, 0x6c, 0x36, 0xe6, 0xb3, 0x19, 0xa9, 0x19, 0x46, 0x63, 0xcd,
	0xc6, 0x7f, 0x25, 0xa9, 0x71, 0xc6, 0x7e, 0xb1, 0xd2, 0x48, 0xf6, 0x5e, 0xd3, 0x1b, 0x2f, 0x63,
	0xa2, 0x30, 0x58, 0x53, 0xac, 0xfe, 0x26, 0x0b, 0x57, 0xee, 0x46, 0xdd, 0xe6, 0x0b, 0xcb, 0x44,
	0x17, 0x16, 0x09, 0x13, 0x21, 0x55, 0x54, 0xc8, 0x58, 0x7f, 0x73, 0x5e, 0xac, 0x4f, 0xf1, 0xa5,
	0xc3, 0x44, 0x38, 0x31, 0x91, 0x8f, 0x60, 0xa6, 0x58, 0xf8, 0x6b, 0x16, 0xca, 0xf3, 0x34, 0xd1,
	0xcb, 0x50, 0x72, 0x42, 0xa2, 0x36, 0xa2, 0xae, 0x6f, 0xa9, 0xae, 0xbf, 0x1a, 0x6d, 0x9b, 0xa6,
	0xff, 0x26, 0xc8, 0x01, 0x4a, 0x26, 0x96, 0x14, 0xbd, 0xf0, 0xc4, 0xb4, 0x9a, 0x28, 0xab, 0xb6,
	0x4f, 0xa0, 0x44, 0x19, 0x15, 0x14, 0x7b, 0xf6, 0x00, 0x7b, 0x98, 0x39, 0x9f, 0x67, 0xb2, 0x9c,
	0x6d, 0xd4, 0xab, 0x06, 0xb4, 0xa5, 0x31, 0xd1, 0x3e, 0x2c, 0x46, 0xf0, 0xb9, 0x4b, 0x80, 0x8f,
	0xc0, 0x52, 0x53, 0xd4, 0x27, 0x59, 0x58, 0xef, 0x11, 0xf7, 0xd9, 0xa2, 0xf5, 0x27, 0x00, 0xba,
	0xe0, 0x64, 0x1f, 0xfc, 0x1c, 0xcc, 0xce, 0x16, 0xf0, 0x92, 0xc6, 0x6b, 0x73, 0x91, 0xe2, 0xf6,
	0xa3, 0x2c, 0x2c, 0xa7, 0xb9, 0x7d, 0x06, 0xfe, 0x2e, 0xa0, 0xdd, 0xa4, 0x1b, 0xe4, 0x54, 0x37,
	0x78, 0x65, 0x5e, 0x37, 0x98, 0xc9, 0xba, 0xb3, 0xdb, 0xc0, 0xa7, 0x59, 0xc8, 0x77, 0x71, 0x88,
	0x7d, 0x8e, 0xbe, 0x3f, 0x33, 0xc0, 0xe9, 0x57, 0xd5, 0xd5, 0x99, 0x9c, 0x6b, 0x9b, 0x47, 0xbd,
	0x4e, 0xb9, 0x77, 0x4f, 0x99, 0xdf, 0xbe, 0x0e, 0xab, 0xf2, 0x89, 0x18, 0xbb, 0xa2, 0x49, 0x5c,
	0x51, 0x6f, 0xbc, 0xf8, 0x75, 0xc1, 0x51, 0x0d, 0x8a, 0x52, 0x2c, 0x69, 0x74, 0x52, 0x06, 0x7c,
	0x7c, 0xdc, 0xd1, 0x3b, 0xe8, 0x3a, 0xa0, 0xc3, 0xf8, 0xd1, 0x6e, 0x27, 0x14, 0x48, 0xb9, 0xf5,
	0xe4, 0x24, 0x12, 0xff, 0x0a, 0x80, 0xb4, 0xc2, 0x76, 0x09, 0x0b, 0x7c, 0xf3, 0xc6, 0x59, 0x92,
	0x3b, 0x6d, 0xb9, 0x81, 0x7e, 0xa9, 0x67, 0xc1, 0xa9, 0xd7, 0xa3, 0x19, 0xc3, 0xdf, 0xb8, 0x58,
	0xa6, 0x7e, 0x7a, 0x52, 0xab, 0x4c, 0xb0, 0xef, 0x6d, 0x37, 0x4e, 0x81, 0x6c, 0xa8, 0xd9, 0xf0,
	0xe9, 0x57, 0x67, 0x2a, 0x83, 0xdf, 0xb3, 0x00, 0x25, 0x2d, 0xb7, 0x47, 0xf8, 0x48, 0x3e, 0x6b,
	0xe4, 0xd0, 0x9b, 0x9a, 0x50, 0xad, 0xb3, 0x87, 0xde, 0x44, 0x3f, 0x1a, 0x7a, 0x53, 0x15, 0xf1,
	0xed, 0xa4, 0xc1, 0x65, 0x4d, 0x0c, 0x0d, 0xcc, 0x00, 0x73, 0x92, 0x1a, 0x9c, 0x69, 0xa4, 0x3d,
	0xd3, 0xc3, 0x32, 0x8d, 0x4f, 0x2c, 0xb8, 0x3a, 0x93, 0x4d, 0xb1, 0xb1, 0x3f, 0x03, 0x14, 0xa6,
	0x0e, 0x55, 0x6c, 0x26, 0xc6, 0xe8, 0x0b, 0x27, 0xe7, 0x7a, 0x38, 0xd3, 0x2b, 0xff, 0x5f, 0x3d,
	0x3a, 0xa7, 0x22, 0xf0, 0x47, 0x0b, 0x36, 0xd2, 0xc6, 0xc4, 0x6e, 0xdd, 0x81, 0xe5, 0xb4, 0x2d,
	0xc6, 0xa1, 0x17, 0xcf, 0xe3, 0x90, 0xf1, 0xe5, 0x29, 0x7d, 0xf4, 0x56, 0x52, 0xb8, 0xfa, 0xc7,
	0xa2, 0x1b, 0xe7, 0xe6, 0x26, 0xb2, 0x69, 0xba, 0x80, 0x73, 0xd1, 0x14, 0x93, 0xeb, 0x06, 0x81,
	0x87, 0x7e, 0x05, 0xeb, 0x2c, 0x10, 0xb6, 0xcc, 0x72, 0xe2, 0xda, 0xe6, 0xe5, 0xaa, 0xbb, 0xdf,
	0x5b, 0x17, 0xa3, 0xec, 0x5f, 0x27, 0xb5, 0x59, 0xa8, 0x29, 0x1e, 0x4b, 0x2c, 0x10, 0x2d, 0x75,
	0xbe, 0xa7, 0xdf, 0xb5, 0x21, 0xac, 0x3c, 0x7d, 0xb5, 0xee, 0x96, 0x6f, 0x5e, 0xf8, 0xea, 0x95,
	0xb3, 0xae, 0x5d, 0x1e, 0xa4, 0xee, 0xdc, 0x2e, 0xc8, 0x18, 0xfe, 0xfb, 0x61, 0xcd, 0xfa, 0xc6,
	0xef, 0x2d, 0x80, 0xe4, 0x09, 0x8f, 0x5e, 0x85, 0x2f, 0xb5, 0x7e, 0x70, 0xa7, 0x6d, 0xf7, 0xf7,
	0x6e, 0xee, 0xdd, 0xed, 0xdb, 0x77, 0xef, 0xf4, 0xbb, 0x9d, 0x9d, 0xdd, 0xd7, 0x77, 0x3b, 0xed,
	0xb5, 0x4c, 0xa5, 0x74, 0xff, 0x41, 0xbd, 0x78, 0x97, 0xf1, 0x11, 0x71, 0xe8, 0x01, 0x25, 0x2e,
	0x7a, 0x09, 0x36, 0x9e, 0x96, 0x96, 0xab, 0x4e, 0x7b, 0xcd, 0xaa, 0x2c, 0xdf, 0x7f, 0x50, 0x2f,
	0xe8, 0xe9, 0x88, 0xb8, 0xe8, 0x1a, 0x3c, 0x3f, 0x2b, 0xb7, 0x7b, 0xe7, 0x7b, 0x6b, 0xd9, 0xca,
	0xca, 0xfd, 0x07, 0xf5, 0xa5, 0x78, 0x8c, 0x42, 0x0d, 0x40, 0x69, 0x49, 0x83, 0xb7, 0x50, 0x81,
	0xfb, 0x0f, 0xea, 0x79, 0x4d, 0x5b, 0x25, 0xf7, 0xf6, 0x7b, 0xd5, 0x4c, 0xeb, 0xf5, 0x0f, 0x1f,
	0x57, 0xad, 0x47, 0x8f, 0xab, 0xd6, 0x3f, 0x1e, 0x57, 0xad, 0x77, 0x9e, 0x54, 0x33, 0x8f, 0x9e,
	0x54, 0x33, 0x7f, 0x7e, 0x52, 0xcd, 0xfc, 0xf8, 0xd5, 0x33, 0x19, 0x3b, 0x8e, 0x7f, 0xc9, 0x55,
	0xdc, 0x0d, 0xf2, 0xaa, 0x29, 0x7f, 0xeb, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x49, 0x0e, 0x8f,
	0x94, 0xe8, 0x15, 0x00, 0x00,
}

func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	return StakingDescription()
}
func StakingDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
	var gzipped = []byte{
		// 7518 bytes of a gzipped FileDescriptorSet
		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7c, 0x6b, 0x70, 0x24, 0xd7,
		0x75, 0x1e, 0xe6, 0x81, 0xc1, 0xcc, 0x99, 0xc1, 0x4c, 0xe3, 0x02, 0xbb, 0x3b, 0x0b, 0x92, 0x00,
		0x38, 0x7c, 0xec, 0xf2, 0x85, 0x25, 0x97, 0xdc, 0x5d, 0xee, 0xac, 0x65, 0x06, 0xf3, 0x58, 0x10,
		0xbb, 0x78, 0x0c, 0x7b, 0x80, 0xe5, 0xc3, 0x71, 0xba, 0x1a, 0x3d, 0x17, 0x83, 0x26, 0x7a, 0xba,
		0xdb, 0xdd, 0x3d, 0xbb, 0x0b, 0x96, 0x93, 0xa2, 0x4b, 0x79, 0x48, 0x9b, 0x8a, 0x23, 0xdb, 0xa9,
		0x58, 0x96, 0xb5, 0x0a, 0x65, 0x39, 0x91, 0xa3, 0x28, 0x0f, 0x5b, 0x8a, 0x12, 0xc7, 0x95, 0x44,
		0x49, 0x55, 0x12, 0x59, 0x3f, 0x52, 0xb2, 0x7f, 0xc4, 0x76, 0x1e, 0x8c, 0x43, 0xa9, 0x12, 0x46,
		0x51, 0x62, 0x47, 0x66, 0xaa, 0x92, 0x52, 0x29, 0x95, 0xba, 0xaf, 0x7e, 0xcc, 0x03, 0x33, 0xd8,
		0x2c, 0x65, 0x57, 0xf9, 0x17, 0xd0, 0xe7, 0x9e, 0xef, 0xeb, 0x73, 0xcf, 0x3d, 0xf7, 0xdc, 0x73,
		0x6f, 0x77, 0x0f, 0xfc, 0xc1, 0x15, 0x58, 0x6a, 0x5b, 0x56, 0xdb, 0xc0, 0xe7, 0x6c, 0xc7, 0xf2,
		0xac, 0xdd, 0xee, 0xde, 0xb9, 0x16, 0x76, 0x35, 0x47, 0xb7, 0x3d, 0xcb, 0x59, 0xa6, 0x32, 0x54,
		0x60, 0x1a, 0xcb, 0x42, 0xa3, 0xb4, 0x01, 0x33, 0x57, 0x75, 0x03, 0xd7, 0x7c, 0xc5, 0x26, 0xf6,
		0xd0, 0x8b, 0x90, 0xdc, 0xd3, 0x0d, 0x5c, 0x8c, 0x2d, 0x25, 0xce, 0x66, 0xcf, 0x3f, 0xba, 0xdc,
		0x03, 0x5a, 0x8e, 0x22, 0x1a, 0x44, 0x2c, 0x53, 0x44, 0xe9, 0x5b, 0x49, 0x98, 0x1d, 0xd0, 0x8a,
		0x10, 0x24, 0x4d, 0xb5, 0x43, 0x18, 0x63, 0x67, 0x33, 0x32, 0xfd, 0x1f, 0x15, 0x61, 0xca, 0x56,
		0xb5, 0x03, 0xb5, 0x8d, 0x8b, 0x71, 0x2a, 0x16, 0x97, 0x68, 0x01, 0xa0, 0x85, 0x6d, 0x6c, 0xb6,
		0xb0, 0xa9, 0x1d, 0x16, 0x13, 0x4b, 0x89, 0xb3, 0x19, 0x39, 0x24, 0x41, 0x4f, 0xc1, 0x8c, 0xdd,
		0xdd, 0x35, 0x74, 0x4d, 0x09, 0xa9, 0xc1, 0x52, 0xe2, 0xec, 0xa4, 0x2c, 0xb1, 0x86, 0x5a, 0xa0,
		0x7c, 0x06, 0x0a, 0xb7, 0xb0, 0x7a, 0x10, 0x56, 0xcd, 0x52, 0xd5, 0x3c, 0x11, 0x87, 0x14, 0xab,
		0x90, 0xeb, 0x60, 0xd7, 0x55, 0xdb, 0x58, 0xf1, 0x0e, 0x6d, 0x5c, 0x4c, 0xd2, 0xde, 0x2f, 0xf5,
		0xf5, 0xbe, 0xb7, 0xe7, 0x59, 0x8e, 0xda, 0x3e, 0xb4, 0x31, 0x5a, 0x81, 0x0c, 0x36, 0xbb, 0x1d,
		0xc6, 0x30, 0x39, 0xc4, 0x7f, 0x75, 0xb3, 0xdb, 0xe9, 0x65, 0x49, 0x13, 0x18, 0xa7, 0x98, 0x72,
		0xb1, 0x73, 0x53, 0xd7, 0x70, 0x31, 0x45, 0x09, 0xce, 0xf4, 0x11, 0x34, 0x59, 0x7b, 0x2f, 0x87,
		0xc0, 0xa1, 0x2a, 0x64, 0xf0, 0x6d, 0x0f, 0x9b, 0xae, 0x6e, 0x99, 0xc5, 0x29, 0x4a, 0xf2, 0xd8,
		0x80, 0x51, 0xc4, 0x46, 0xab, 0x97, 0x22, 0xc0, 0xa1, 0x8b, 0x30, 0x65, 0xd9, 0x9e, 0x6e, 0x99,
		0x6e, 0x31, 0xbd, 0x14, 0x3b, 0x9b, 0x3d, 0xff, 0xe0, 0xc0, 0x40, 0xd8, 0x62, 0x3a, 0xb2, 0x50,
		0x46, 0x6b, 0x20, 0xb9, 0x56, 0xd7, 0xd1, 0xb0, 0xa2, 0x59, 0x2d, 0xac, 0xe8, 0xe6, 0x9e, 0x55,
		0xcc, 0x50, 0x82, 0xc5, 0xfe, 0x8e, 0x50, 0xc5, 0xaa, 0xd5, 0xc2, 0x6b, 0xe6, 0x9e, 0x25, 0xe7,
		0xdd, 0xc8, 0x35, 0x3a, 0x09, 0x29, 0xf7, 0xd0, 0xf4, 0xd4, 0xdb, 0xc5, 0x1c, 0x8d, 0x10, 0x7e,
		0x55, 0xfa, 0xd5, 0x14, 0x14, 0xc6, 0x09, 0xb1, 0x2b, 0x30, 0xb9, 0x47, 0x7a, 0x59, 0x8c, 0x1f,
		0xc7, 0x07, 0x0c, 0x13, 0x75, 0x62, 0xea, 0x1e, 0x9d, 0xb8, 0x02, 0x59, 0x13, 0xbb, 0x1e, 0x6e,
		0xb1, 0x88, 0x48, 0x8c, 0x19, 0x53, 0xc0, 0x40, 0xfd, 0x21, 0x95, 0xbc, 0xa7, 0x90, 0x7a, 0x0d,
		0x0a, 0xbe, 0x49, 0x8a, 0xa3, 0x9a, 0x6d, 0x11, 0x9b, 0xe7, 0x46, 0x59, 0xb2, 0x5c, 0x17, 0x38,
		0x99, 0xc0, 0xe4, 0x3c, 0x8e, 0x5c, 0xa3, 0x1a, 0x80, 0x65, 0x62, 0x6b, 0x4f, 0x69, 0x61, 0xcd,
		0x28, 0xa6, 0x87, 0x78, 0x69, 0x8b, 0xa8, 0xf4, 0x79, 0xc9, 0x62, 0x52, 0xcd, 0x40, 0x97, 0x83,
		0x50, 0x9b, 0x1a, 0x12, 0x29, 0x1b, 0x6c, 0x92, 0xf5, 0x45, 0xdb, 0x0e, 0xe4, 0x1d, 0x4c, 0xe2,
		0x1e, 0xb7, 0x78, 0xcf, 0x32, 0xd4, 0x88, 0xe5, 0x91, 0x3d, 0x93, 0x39, 0x8c, 0x75, 0x6c, 0xda,
		0x09, 0x5f, 0xa2, 0x47, 0xc0, 0x17, 0x28, 0x34, 0xac, 0x80, 0x66, 0xa1, 0x9c, 0x10, 0x6e, 0xaa,
		0x1d, 0x3c, 0xff, 0x16, 0xe4, 0xa3, 0xee, 0x41, 0x73, 0x30, 0xe9, 0x7a, 0xaa, 0xe3, 0xd1, 0x28,
		0x9c, 0x94, 0xd9, 0x05, 0x92, 0x20, 0x81, 0xcd, 0x16, 0xcd, 0x72, 0x93, 0x32, 0xf9, 0x17, 0xfd,
		0x89, 0xa0, 0xc3, 0x09, 0xda, 0xe1, 0xc7, 0xfb, 0x47, 0x34, 0xc2, 0xdc, 0xdb, 0xef, 0xf9, 0x4b,
		0x30, 0x1d, 0xe9, 0xc0, 0xb8, 0xb7, 0x2e, 0xfd, 0x38, 0x9c, 0x18, 0x48, 0x8d, 0x5e, 0x83, 0xb9,
		0xae, 0xa9, 0x9b, 0x1e, 0x76, 0x6c, 0x07, 0x93, 0x88, 0x65, 0xb7, 0x2a, 0xfe, 0x97, 0xa9, 0x21,
		0x31, 0xb7, 0x13, 0xd6, 0x66, 0x2c, 0xf2, 0x6c, 0xb7, 0x5f, 0xf8, 0x64, 0x26, 0xfd, 0xfe, 0x94,
		0xf4, 0xf6, 0xdb, 0x6f, 0xbf, 0x1d, 0x2f, 0xfd, 0xb3, 0x14, 0xcc, 0x0d, 0x9a, 0x33, 0x03, 0xa7,
		0xef, 0x49, 0x48, 0x99, 0xdd, 0xce, 0x2e, 0x76, 0xa8, 0x93, 0x26, 0x65, 0x7e, 0x85, 0x56, 0x60,
		0xd2, 0x50, 0x77, 0xb1, 0x51, 0x4c, 0x2e, 0xc5, 0xce, 0xe6, 0xcf, 0x3f, 0x35, 0xd6, 0xac, 0x5c,
		0x5e, 0x27, 0x10, 0x99, 0x21, 0xd1, 0x0f, 0x43, 0x92, 0xa7, 0x68, 0xc2, 0xf0, 0xe4, 0x78, 0x0c,
		0x64, 0x2e, 0xc9, 0x14, 0x87, 0x1e, 0x80, 0x0c, 0xf9, 0xcb, 0x62, 0x23, 0x45, 0x6d, 0x4e, 0x13,
		0x01, 0x89, 0x0b, 0x34, 0x0f, 0x69, 0x3a, 0x4d, 0x5a, 0x58, 0x2c, 0x6d, 0xfe, 0x35, 0x09, 0xac,
		0x16, 0xde, 0x53, 0xbb, 0x86, 0xa7, 0xdc, 0x54, 0x8d, 0x2e, 0xa6, 0x01, 0x9f, 0x91, 0x73, 0x5c,
		0x78, 0x83, 0xc8, 0xd0, 0x22, 0x64, 0xd9, 0xac, 0xd2, 0xcd, 0x16, 0xbe, 0x4d, 0xb3, 0xe7, 0xa4,
		0xcc, 0x26, 0xda, 0x1a, 0x91, 0x90, 0xdb, 0xbf, 0xe9, 0x5a, 0xa6, 0x08, 0x4d, 0x7a, 0x0b, 0x22,
		0xa0, 0xb7, 0xbf, 0xd4, 0x9b, 0xb8, 0x1f, 0x1a, 0xdc, 0xbd, 0xbe, 0xb9, 0x74, 0x06, 0x0a, 0x54,
		0xe3, 0x79, 0x3e, 0xf4, 0xaa, 0x51, 0x9c, 0x59, 0x8a, 0x9d, 0x4d, 0xcb, 0x79, 0x26, 0xde, 0xe2,
		0xd2, 0xd2, 0x57, 0xe2, 0x90, 0xa4, 0x89, 0xa5, 0x00, 0xd9, 0xed, 0xd7, 0x1b, 0x75, 0xa5, 0xb6,
		0xb5, 0x53, 0x59, 0xaf, 0x4b, 0x31, 0x94, 0x07, 0xa0, 0x82, 0xab, 0xeb, 0x5b, 0x2b, 0xdb, 0x52,
		0xdc, 0xbf, 0x5e, 0xdb, 0xdc, 0xbe, 0xf8, 0x82, 0x94, 0xf0, 0x01, 0x3b, 0x4c, 0x90, 0x0c, 0x2b,
		0x3c, 0x7f, 0x5e, 0x9a, 0x44, 0x12, 0xe4, 0x18, 0xc1, 0xda, 0x6b, 0xf5, 0xda, 0xc5, 0x17, 0xa4,
		0x54, 0x54, 0xf2, 0xfc, 0x79, 0x69, 0x0a, 0x4d, 0x43, 0x86, 0x4a, 0x2a, 0x5b, 0x5b, 0xeb, 0x52,
		0xda, 0xe7, 0x6c, 0x6e, 0xcb, 0x6b, 0x9b, 0xab, 0x52, 0xc6, 0xe7, 0x5c, 0x95, 0xb7, 0x76, 0x1a,
		0x12, 0xf8, 0x0c, 0x1b, 0xf5, 0x66, 0x73, 0x65, 0xb5, 0x2e, 0x65, 0x7d, 0x8d, 0xca, 0xeb, 0xdb,
		0xf5, 0xa6, 0x94, 0x8b, 0x98, 0xf5, 0xfc, 0x79, 0x69, 0xda, 0xbf, 0x45, 0x7d, 0x73, 0x67, 0x43,
		0xca, 0xa3, 0x19, 0x98, 0x66, 0xb7, 0x10, 0x46, 0x14, 0x7a, 0x44, 0x17, 0x5f, 0x90, 0xa4, 0xc0,
		0x10, 0xc6, 0x32, 0x13, 0x11, 0x5c, 0x7c, 0x41, 0x42, 0xa5, 0x2a, 0x4c, 0xd2, 0x30, 0x44, 0x08,
		0xf2, 0xeb, 0x2b, 0x95, 0xfa, 0xba, 0xb2, 0xd5, 0xd8, 0x5e, 0xdb, 0xda, 0x5c, 0x59, 0x97, 0x62,
		0x81, 0x4c, 0xae, 0xbf, 0xb2, 0xb3, 0x26, 0xd7, 0x6b, 0x52, 0x3c, 0x2c, 0x6b, 0xd4, 0x57, 0xb6,
		0xeb, 0x35, 0x29, 0x51, 0xd2, 0x60, 0x6e, 0x50, 0x42, 0x1d, 0x38, 0x85, 0x42, 0xb1, 0x10, 0x1f,
		0x12, 0x0b, 0x94, 0xab, 0x37, 0x16, 0x4a, 0xdf, 0x8c, 0xc3, 0xec, 0x80, 0x45, 0x65, 0xe0, 0x4d,
		0x5e, 0x82, 0x49, 0x16, 0xcb, 0x6c, 0x99, 0x7d, 0x62, 0xe0, 0xea, 0x44, 0x23, 0xbb, 0x6f, 0xa9,
		0xa5, 0xb8, 0x70, 0xa9, 0x91, 0x18, 0x52, 0x6a, 0x10, 0x8a, 0xbe, 0x80, 0xfd, 0xd1, 0xbe, 0xe4,
		0xcf, 0xd6, 0xc7, 0x8b, 0xe3, 0xac, 0x8f, 0x54, 0x76, 0xbc, 0x45, 0x60, 0x72, 0xc0, 0x22, 0x70,
		0x05, 0x66, 0xfa, 0x88, 0xc6, 0x4e, 0xc6, 0x1f, 0x8d, 0x41, 0x71, 0x98, 0x73, 0x46, 0xa4, 0xc4,
		0x78, 0x24, 0x25, 0x5e, 0xe9, 0xf5, 0xe0, 0xc3, 0xc3, 0x07, 0xa1, 0x6f, 0xac, 0x3f, 0x1f, 0x83,
		0x93, 0x83, 0x4b, 0xca, 0x81, 0x36, 0xfc, 0x30, 0xa4, 0x3a, 0xd8, 0xdb, 0xb7, 0x44, 0x59, 0xf5,
		0xf8, 0x80, 0xc5, 0x9a, 0x34, 0xf7, 0x0e, 0x36, 0x47, 0x85, 0x57, 0xfb, 0xc4, 0xb0, 0xba, 0x90,
		0x59, 0xd3, 0x67, 0xe9, 0xc7, 0xe3, 0x70, 0x62, 0x20, 0xf9, 0x40, 0x43, 0x1f, 0x02, 0xd0, 0x4d,
		0xbb, 0xeb, 0xb1, 0xd2, 0x89, 0x65, 0xe2, 0x0c, 0x95, 0xd0, 0xe4, 0x45, 0xb2, 0x6c, 0xd7, 0xf3,
		0xdb, 0x13, 0xb4, 0x1d, 0x98, 0x88, 0x2a, 0xbc, 0x18, 0x18, 0x9a, 0xa4, 0x86, 0x2e, 0x0c, 0xe9,
		0x69, 0x5f, 0x60, 0x3e, 0x0b, 0x92, 0x66, 0xe8, 0xd8, 0xf4, 0x14, 0xd7, 0x73, 0xb0, 0xda, 0xd1,
		0xcd, 0x36, 0x5d, 0x6a, 0xd2, 0xe5, 0xc9, 0x3d, 0xd5, 0x70, 0xb1, 0x5c, 0x60, 0xcd, 0x4d, 0xd1,
		0x4a, 0x10, 0x34, 0x80, 0x9c, 0x10, 0x22, 0x15, 0x41, 0xb0, 0x66, 0x1f, 0x51, 0xfa, 0xa9, 0x0c,
		0x64, 0x43, 0x05, 0x38, 0x7a, 0x18, 0x72, 0x6f, 0xaa, 0x37, 0x55, 0x45, 0x6c, 0xaa, 0x98, 0x27,
		0xb2, 0x44, 0xd6, 0xe0, 0x1b, 0xab, 0x67, 0x61, 0x8e, 0xaa, 0x58, 0x5d, 0x0f, 0x3b, 0x8a, 0x66,
		0xa8, 0xae, 0x4b, 0x9d, 0x96, 0xa6, 0xaa, 0x88, 0xb4, 0x6d, 0x91, 0xa6, 0xaa, 0x68, 0x41, 0x17,
		0x60, 0x96, 0x22, 0x3a, 0x5d, 0xc3, 0xd3, 0x6d, 0x03, 0x2b, 0x64, 0x9b, 0xe7, 0xd2, 0x25, 0xc7,
		0xb7, 0x6c, 0x86, 0x68, 0x6c, 0x70, 0x05, 0x62, 0x91, 0x8b, 0x6a, 0xf0, 0x10, 0x85, 0xb5, 0xb1,
		0x89, 0x1d, 0xd5, 0xc3, 0x0a, 0xfe, 0xb1, 0xae, 0x6a, 0xb8, 0x8a, 0x6a, 0xb6, 0x94, 0x7d, 0xd5,
		0xdd, 0x2f, 0xce, 0x11, 0x82, 0x4a, 0xbc, 0x18, 0x93, 0x4f, 0x13, 0xc5, 0x55, 0xae, 0x57, 0xa7,
		0x6a, 0x2b, 0x66, 0xeb, 0x65, 0xd5, 0xdd, 0x47, 0x65, 0x38, 0x49, 0x59, 0x5c, 0xcf, 0xd1, 0xcd,
		0xb6, 0xa2, 0xed, 0x63, 0xed, 0x40, 0xe9, 0x7a, 0x7b, 0x2f, 0x16, 0x1f, 0x08, 0xdf, 0x9f, 0x5a,
		0xd8, 0xa4, 0x3a, 0x55, 0xa2, 0xb2, 0xe3, 0xed, 0xbd, 0x88, 0x9a, 0x90, 0x23, 0x83, 0xd1, 0xd1,
		0xdf, 0xc2, 0xca, 0x9e, 0xe5, 0xd0, 0x35, 0x34, 0x3f, 0x20, 0x35, 0x85, 0x3c, 0xb8, 0xbc, 0xc5,
		0x01, 0x1b, 0x56, 0x0b, 0x97, 0x27, 0x9b, 0x8d, 0x7a, 0xbd, 0x26, 0x67, 0x05, 0xcb, 0x55, 0xcb,
		0x21, 0x01, 0xd5, 0xb6, 0x7c, 0x07, 0x67, 0x59, 0x40, 0xb5, 0x2d, 0xe1, 0xde, 0x0b, 0x30, 0xab,
		0x69, 0xac, 0xcf, 0xba, 0xa6, 0xf0, 0xcd, 0x98, 0x5b, 0x94, 0x22, 0xce, 0xd2, 0xb4, 0x55, 0xa6,
		0xc0, 0x63, 0xdc, 0x45, 0x97, 0xe1, 0x44, 0xe0, 0xac, 0x30, 0x70, 0xa6, 0xaf, 0x97, 0xbd, 0xd0,
		0x0b, 0x30, 0x6b, 0x1f, 0xf6, 0x03, 0x51, 0xe4, 0x8e, 0xf6, 0x61, 0x2f, 0xec, 0x12, 0xcc, 0xd9,
		0xfb, 0x76, 0x3f, 0xee, 0xc9, 0x30, 0x0e, 0xd9, 0xfb, 0x76, 0x2f, 0xf0, 0x31, 0xba, 0x33, 0x77,
		0xb0, 0xa6, 0x7a, 0xb8, 0x55, 0x3c, 0x15, 0x56, 0x0f, 0x35, 0xa0, 0x65, 0x90, 0x34, 0x4d, 0xc1,
		0xa6, 0xba, 0x6b, 0x60, 0x45, 0x75, 0xb0, 0xa9, 0xba, 0xc5, 0x45, 0xaa, 0x9c, 0xf4, 0x9c, 0x2e,
		0x96, 0xf3, 0x9a, 0x56, 0xa7, 0x8d, 0x2b, 0xb4, 0x0d, 0x3d, 0x09, 0x33, 0xd6, 0xee, 0x9b, 0x1a,
		0x8b, 0x48, 0xc5, 0x76, 0xf0, 0x9e, 0x7e, 0xbb, 0xf8, 0x28, 0x75, 0x6f, 0x81, 0x34, 0xd0, 0x78,
		0x6c, 0x50, 0x31, 0x7a, 0x02, 0x24, 0xcd, 0xdd, 0x57, 0x1d, 0x9b, 0xa6, 0x64, 0xd7, 0x56, 0x35,
		0x5c, 0x7c, 0x8c, 0xa9, 0x32, 0xf9, 0xa6, 0x10, 0x93, 0x19, 0xe1, 0xde, 0xd2, 0xf7, 0x3c, 0xc1,
		0x78, 0x86, 0xcd, 0x08, 0x2a, 0xe3, 0x6c, 0x67, 0x41, 0x22, 0x9e, 0x88, 0xdc, 0xf8, 0x2c, 0x55,
		0xcb, 0xdb, 0xfb, 0x76, 0xf8, 0xbe, 0x8f, 0xc0, 0x34, 0xd1, 0x0c, 0x6e, 0xfa, 0x04, 0x2b, 0xdc,
		0xec, 0xfd, 0xd0, 0x1d, 0x5f, 0x80, 0x93, 0x44, 0xa9, 0x83, 0x3d, 0xb5, 0xa5, 0x7a, 0x6a, 0x48,
		0xfb, 0x69, 0xaa, 0x4d, 0xdc, 0xbe, 0xc1, 0x1b, 0x23, 0x76, 0x3a, 0xdd, 0xdd, 0x43, 0x3f, 0xb0,
		0x9e, 0x61, 0x76, 0x12, 0x99, 0x08, 0xad, 0x0f, 0xad, 0x38, 0x2f, 0x95, 0x21, 0x17, 0x8e, 0x7b,
		0x94, 0x01, 0x16, 0xf9, 0x52, 0x8c, 0x14, 0x41, 0xd5, 0xad, 0x1a, 0x29, 0x5f, 0xde, 0xa8, 0x4b,
		0x71, 0x52, 0x46, 0xad, 0xaf, 0x6d, 0xd7, 0x15, 0x79, 0x67, 0x73, 0x7b, 0x6d, 0xa3, 0x2e, 0x25,
		0x42, 0x85, 0xfd, 0xb5, 0x64, 0xfa, 0x71, 0xe9, 0x0c, 0xa9, 0x1a, 0xf2, 0xd1, 0x9d, 0x1a, 0xfa,
		0x21, 0x38, 0x25, 0x8e, 0x55, 0x5c, 0xec, 0x29, 0xb7, 0x74, 0x87, 0x4e, 0xc8, 0x8e, 0xca, 0x16,
		0x47, 0x3f, 0x7e, 0xe6, 0xb8, 0x56, 0x13, 0x7b, 0xaf, 0xea, 0x0e, 0x99, 0x6e, 0x1d, 0xd5, 0x43,
		0xeb, 0xb0, 0x68, 0x5a, 0x8a, 0xeb, 0xa9, 0x66, 0x4b, 0x75, 0x5a, 0x4a, 0x70, 0xa0, 0xa5, 0xa8,
		0x9a, 0x86, 0x5d, 0xd7, 0x62, 0x0b, 0xa1, 0xcf, 0xf2, 0xa0, 0x69, 0x35, 0xb9, 0x72, 0xb0, 0x42,
		0xac, 0x70, 0xd5, 0x9e, 0xf0, 0x4d, 0x0c, 0x0b, 0xdf, 0x07, 0x20, 0xd3, 0x51, 0x6d, 0x05, 0x9b,
		0x9e, 0x73, 0x48, 0xeb, 0xf3, 0xb4, 0x9c, 0xee, 0xa8, 0x76, 0x9d, 0x5c, 0xff, 0x40, 0xb6, 0x49,
		0xd7, 0x92, 0xe9, 0xa4, 0x34, 0x79, 0x2d, 0x99, 0x9e, 0x94, 0x52, 0xd7, 0x92, 0xe9, 0x94, 0x34,
		0x75, 0x2d, 0x99, 0x4e, 0x4b, 0x99, 0x6b, 0xc9, 0x74, 0x46, 0x82, 0xd2, 0x4f, 0x27, 0x21, 0x17,
		0xae, 0xe0, 0xc9, 0x86, 0x48, 0xa3, 0x6b, 0x58, 0x8c, 0x66, 0xb9, 0x47, 0x8e, 0xac, 0xf7, 0x97,
		0xab, 0x64, 0x71, 0x2b, 0xa7, 0x58, 0xb9, 0x2c, 0x33, 0x24, 0x29, 0x2c, 0x48, 0xf8, 0x61, 0x56,
		0x9e, 0xa4, 0x65, 0x7e, 0x85, 0x56, 0x21, 0xf5, 0xa6, 0x4b, 0xb9, 0x53, 0x94, 0xfb, 0xd1, 0xa3,
		0xb9, 0xaf, 0x35, 0x29, 0x79, 0xe6, 0x5a, 0x53, 0xd9, 0xdc, 0x92, 0x37, 0x56, 0xd6, 0x65, 0x0e,
		0x47, 0xa7, 0x21, 0x69, 0xa8, 0x6f, 0x1d, 0x46, 0x97, 0x41, 0x2a, 0x42, 0xcb, 0x50, 0xe8, 0x9a,
		0x37, 0xb1, 0xa3, 0xef, 0xe9, 0xb8, 0xa5, 0x50, 0xad, 0x42, 0x58, 0x2b, 0x1f, 0xb4, 0xae, 0x13,
		0xfd, 0x31, 0x87, 0xf1, 0x34, 0x24, 0x6f, 0x61, 0xf5, 0x20, 0xba, 0x58, 0x51, 0xd1, 0x87, 0x38,
		0x9d, 0xce, 0xc1, 0x24, 0xf5, 0x2f, 0x02, 0xe0, 0x1e, 0x96, 0x26, 0x50, 0x1a, 0x92, 0xd5, 0x2d,
		0x99, 0x4c, 0x29, 0x09, 0x72, 0x4c, 0xaa, 0x34, 0xd6, 0xea, 0xd5, 0xba, 0x14, 0x2f, 0x5d, 0x80,
		0x14, 0x73, 0x1a, 0x99, 0x6e, 0xbe, 0xdb, 0xa4, 0x09, 0x7e, 0xc9, 0x39, 0x62, 0xa2, 0x75, 0x67,
		0xa3, 0x52, 0x97, 0xa5, 0x78, 0x5f, 0xb0, 0x94, 0x5c, 0xc8, 0x85, 0x2b, 0xf9, 0x1f, 0xcc, 0x76,
		0xfe, 0xab, 0x31, 0xc8, 0x86, 0x2a, 0x73, 0x52, 0x52, 0xa9, 0x86, 0x61, 0xdd, 0x52, 0x54, 0x43,
		0x57, 0x5d, 0x1e, 0x4a, 0x40, 0x45, 0x2b, 0x44, 0x32, 0xee, 0xd0, 0xfd, 0x80, 0x26, 0xd9, 0xa4,
		0x94, 0x2a, 0x7d, 0x26, 0x06, 0x52, 0x6f, 0x69, 0xdc, 0x63, 0x66, 0xec, 0x0f, 0xd3, 0xcc, 0xd2,
		0xa7, 0x63, 0x90, 0x8f, 0xd6, 0xc3, 0x3d, 0xe6, 0x3d, 0xfc, 0x87, 0x6a, 0xde, 0xef, 0xc6, 0x61,
		0x3a, 0x52, 0x05, 0x8f, 0x6b, 0xdd, 0x8f, 0xc1, 0x8c, 0xde, 0xc2, 0x1d, 0xdb, 0xf2, 0xb0, 0xa9,
		0x1d, 0x2a, 0x06, 0xbe, 0x89, 0x8d, 0x62, 0x89, 0x26, 0x99, 0x73, 0x47, 0xd7, 0xd9, 0xcb, 0x6b,
		0x01, 0x6e, 0x9d, 0xc0, 0xca, 0xb3, 0x6b, 0xb5, 0xfa, 0x46, 0x63, 0x6b, 0xbb, 0xbe, 0x59, 0x7d,
		0x5d, 0xd9, 0xd9, 0xbc, 0xbe, 0xb9, 0xf5, 0xea, 0xa6, 0x2c, 0xe9, 0x3d, 0x6a, 0x1f, 0xe2, 0xb4,
		0x6f, 0x80, 0xd4, 0x6b, 0x14, 0x3a, 0x05, 0x83, 0xcc, 0x92, 0x26, 0xd0, 0x2c, 0x14, 0x36, 0xb7,
		0x94, 0xe6, 0x5a, 0xad, 0xae, 0xd4, 0xaf, 0x5e, 0xad, 0x57, 0xb7, 0x9b, 0xec, 0xe4, 0xc4, 0xd7,
		0xde, 0x8e, 0x4c, 0xf0, 0xd2, 0xa7, 0x12, 0x30, 0x3b, 0xc0, 0x12, 0xb4, 0xc2, 0xf7, 0x3c, 0x6c,
		0x1b, 0xf6, 0xcc, 0x38, 0xd6, 0x2f, 0x93, 0xaa, 0xa3, 0xa1, 0x3a, 0x1e, 0xdf, 0x22, 0x3d, 0x01,
		0xc4, 0x4b, 0xa6, 0x47, 0x92, 0xab, 0xc3, 0x4f, 0xa4, 0xd8, 0x46, 0xa8, 0x10, 0xc8, 0xd9, 0xa1,
		0xd4, 0xd3, 0x80, 0x6c, 0xcb, 0xd5, 0x3d, 0xfd, 0x26, 0x56, 0x74, 0x53, 0x1c, 0x5f, 0x91, 0x8d,
		0x51, 0x52, 0x96, 0x44, 0xcb, 0x9a, 0xe9, 0xf9, 0xda, 0x26, 0x6e, 0xab, 0x3d, 0xda, 0x24, 0xf9,
		0x27, 0x64, 0x49, 0xb4, 0xf8, 0xda, 0x0f, 0x43, 0xae, 0x65, 0x75, 0x49, 0xb5, 0xc8, 0xf4, 0xc8,
		0x5a, 0x13, 0x93, 0xb3, 0x4c, 0xe6, 0xab, 0xf0, 0x7d, 0x40, 0x70, 0x6e, 0x96, 0x93, 0xb3, 0x4c,
		0xc6, 0x54, 0xce, 0x40, 0x41, 0x6d, 0xb7, 0x1d, 0x42, 0x2e, 0x88, 0xd8, 0xce, 0x26, 0xef, 0x8b,
		0xa9, 0xe2, 0xfc, 0x35, 0x48, 0x0b, 0x3f, 0x90, 0xc5, 0x9e, 0x78, 0x42, 0xb1, 0xd9, 0x76, 0x3d,
		0x7e, 0x36, 0x23, 0xa7, 0x4d, 0xd1, 0xf8, 0x30, 0xe4, 0x74, 0x57, 0x09, 0x1e, 0x03, 0xc4, 0x97,
		0xe2, 0x67, 0xd3, 0x72, 0x56, 0x77, 0xfd, 0x23, 0xd4, 0xd2, 0xe7, 0xe3, 0x90, 0x8f, 0x3e, 0xc6,
		0x40, 0x35, 0x48, 0x1b, 0x96, 0xa6, 0xd2, 0xd0, 0x62, 0xcf, 0xd0, 0xce, 0x8e, 0x78, 0xf2, 0xb1,
		0xbc, 0xce, 0xf5, 0x65, 0x1f, 0x39, 0xff, 0xaf, 0x63, 0x90, 0x16, 0x62, 0x74, 0x12, 0x92, 0xb6,
		0xea, 0xed, 0x53, 0xba, 0xc9, 0x4a, 0x5c, 0x8a, 0xc9, 0xf4, 0x9a, 0xc8, 0x5d, 0x5b, 0x35, 0x69,
		0x08, 0x70, 0x39, 0xb9, 0x26, 0xe3, 0x6a, 0x60, 0xb5, 0x45, 0xb7, 0x4d, 0x56, 0xa7, 0x83, 0x4d,
		0xcf, 0x15, 0xe3, 0xca, 0xe5, 0x55, 0x2e, 0x46, 0x4f, 0xc1, 0x8c, 0xe7, 0xa8, 0xba, 0x11, 0xd1,
		0x4d, 0x52, 0x5d, 0x49, 0x34, 0xf8, 0xca, 0x65, 0x38, 0x2d, 0x78, 0x5b, 0xd8, 0x53, 0xb5, 0x7d,
		0xdc, 0x0a, 0x40, 0x29, 0x7a, 0x3c, 0x72, 0x8a, 0x2b, 0xd4, 0x78, 0xbb, 0xc0, 0x96, 0x7e, 0x23,
		0x06, 0x33, 0x62, 0xa3, 0xd7, 0xf2, 0x9d, 0xb5, 0x01, 0xa0, 0x9a, 0xa6, 0xe5, 0x85, 0xdd, 0xd5,
		0x1f, 0xca, 0x7d, 0xb8, 0xe5, 0x15, 0x1f, 0x24, 0x87, 0x08, 0xe6, 0x3b, 0x00, 0x41, 0xcb, 0x50,
		0xb7, 0x2d, 0x42, 0x96, 0x3f, 0xa3, 0xa2, 0x0f, 0x3a, 0xd9, 0xd1, 0x00, 0x30, 0x11, 0xd9, 0x11,
		0xa2, 0x39, 0x98, 0xdc, 0xc5, 0x6d, 0xdd, 0xe4, 0x27, 0xcf, 0xec, 0x42, 0x1c, 0xe0, 0x24, 0xfd,
		0x03, 0x9c, 0xca, 0x9f, 0x81, 0x59, 0xcd, 0xea, 0xf4, 0x9a, 0x5b, 0x91, 0x7a, 0x8e, 0x27, 0xdc,
		0x97, 0x63, 0x6f, 0x3c, 0xc3, 0x95, 0xda, 0x96, 0xa1, 0x9a, 0xed, 0x65, 0xcb, 0x69, 0x07, 0x0f,
		0x6a, 0x49, 0x85, 0xe4, 0x86, 0x1e, 0xd7, 0xda, 0xbb, 0xff, 0x3b, 0x16, 0xfb, 0x85, 0x78, 0x62,
		0xb5, 0x51, 0xf9, 0x42, 0x7c, 0x7e, 0x95, 0x01, 0x1b, 0xc2, 0x19, 0x32, 0xde, 0x33, 0xb0, 0x46,
		0x3a, 0x08, 0xdf, 0x7e, 0x0a, 0xe6, 0xda, 0x56, 0xdb, 0xa2, 0x4c, 0xe7, 0xc8, 0x7f, 0xfc, 0x49,
		0x6f, 0xc6, 0x97, 0xce, 0x8f, 0x7c, 0x2c, 0x5c, 0xde, 0x84, 0x59, 0xae, 0xac, 0xd0, 0x47, 0x4d,
		0x6c, 0x23, 0x84, 0x8e, 0x3c, 0x85, 0x2b, 0xfe, 0xf2, 0xb7, 0xe8, 0xf2, 0x2d, 0xcf, 0x70, 0x28,
		0x69, 0x63, 0x7b, 0xa5, 0xb2, 0x0c, 0x27, 0x22, 0x7c, 0x6c, 0x92, 0x62, 0x67, 0x04, 0xe3, 0xbf,
		0xe0, 0x8c, 0xb3, 0x21, 0xc6, 0x26, 0x87, 0x96, 0xab, 0x30, 0x7d, 0x1c, 0xae, 0x7f, 0xc9, 0xb9,
		0x72, 0x38, 0x4c, 0xb2, 0x0a, 0x05, 0x4a, 0xa2, 0x75, 0x5d, 0xcf, 0xea, 0xd0, 0x0c, 0x78, 0x34,
		0xcd, 0xbf, 0xfa, 0x16, 0x9b, 0x35, 0x79, 0x02, 0xab, 0xfa, 0xa8, 0x72, 0x19, 0xe8, 0xd3, 0xb5,
		0x16, 0xd6, 0x8c, 0x11, 0x0c, 0x5f, 0xe3, 0x86, 0xf8, 0xfa, 0xe5, 0x1b, 0x30, 0x47, 0xfe, 0xa7,
		0x09, 0x2a, 0x6c, 0xc9, 0xe8, 0x23, 0xbb, 0xe2, 0x6f, 0x7c, 0x94, 0x4d, 0xcc, 0x59, 0x9f, 0x20,
		0x64, 0x53, 0x68, 0x14, 0xdb, 0xd8, 0xf3, 0xb0, 0xe3, 0x2a, 0xaa, 0x31, 0xc8, 0xbc, 0xd0, 0x99,
		0x47, 0xf1, 0xe7, 0xbe, 0x13, 0x1d, 0xc5, 0x55, 0x86, 0x5c, 0x31, 0x8c, 0xf2, 0x0e, 0x9c, 0x1a,
		0x10, 0x15, 0x63, 0x70, 0x7e, 0x8a, 0x73, 0xce, 0xf5, 0x45, 0x06, 0xa1, 0x6d, 0x80, 0x90, 0xfb,
		0x63, 0x39, 0x06, 0xe7, 0xcf, 0x73, 0x4e, 0xc4, 0xb1, 0x62, 0x48, 0x09, 0xe3, 0x35, 0x98, 0xb9,
		0x89, 0x9d, 0x5d, 0xcb, 0xe5, 0xe7, 0x4c, 0x63, 0xd0, 0x7d, 0x9a, 0xd3, 0x15, 0x38, 0x90, 0x1e,
		0x3c, 0x11, 0xae, 0xcb, 0x90, 0xde, 0x53, 0x35, 0x3c, 0x06, 0xc5, 0x5d, 0x4e, 0x31, 0x45, 0xf4,
		0x09, 0x74, 0x05, 0x72, 0x6d, 0x8b, 0xaf, 0x51, 0xa3, 0xe1, 0x9f, 0xe1, 0xf0, 0xac, 0xc0, 0x70,
		0x0a, 0xdb, 0xb2, 0xbb, 0x06, 0x59, 0xc0, 0x46, 0x53, 0xfc, 0x35, 0x41, 0x21, 0x30, 0x9c, 0xe2,
		0x18, 0x6e, 0x7d, 0x47, 0x50, 0xb8, 0x21, 0x7f, 0xbe, 0x04, 0x59, 0xcb, 0x34, 0x0e, 0x2d, 0x73,
		0x1c, 0x23, 0x3e, 0xcb, 0x19, 0x80, 0x43, 0x08, 0xc1, 0x15, 0xc8, 0x8c, 0x3b, 0x10, 0x7f, 0xfd,
		0x3b, 0x62, 0x7a, 0x88, 0x11, 0x58, 0x85, 0x82, 0x48, 0x50, 0xba, 0x65, 0x8e, 0x41, 0xf1, 0x37,
		0x38, 0x45, 0x3e, 0x04, 0xe3, 0xdd, 0xf0, 0xb0, 0xeb, 0xb5, 0xf1, 0x38, 0x24, 0x9f, 0x17, 0xdd,
		0xe0, 0x10, 0xee, 0xca, 0x5d, 0x6c, 0x6a, 0xfb, 0xe3, 0x31, 0xfc, 0x92, 0x70, 0xa5, 0xc0, 0x10,
		0x8a, 0x2a, 0x4c, 0x77, 0x54, 0xc7, 0xdd, 0x57, 0x8d, 0xb1, 0x86, 0xe3, 0x6f, 0x72, 0x8e, 0x9c,
		0x0f, 0xe2, 0x1e, 0xe9, 0x9a, 0xc7, 0xa1, 0xf9, 0x82, 0xf0, 0x48, 0x08, 0xc6, 0xa7, 0x9e, 0xeb,
		0xd1, 0x43, 0xb9, 0xe3, 0xb0, 0xfd, 0x2d, 0x31, 0xf5, 0x18, 0x76, 0x23, 0xcc, 0x78, 0x05, 0x32,
		0xae, 0xfe, 0xd6, 0x58, 0x34, 0x5f, 0x14, 0x23, 0x4d, 0x01, 0x04, 0xfc, 0x3a, 0x9c, 0x1e, 0xb8,
		0x4c, 0x8c, 0x41, 0xf6, 0xb7, 0x39, 0xd9, 0xc9, 0x01, 0x4b, 0x05, 0x4f, 0x09, 0xc7, 0xa5, 0xfc,
		0x3b, 0x22, 0x25, 0xe0, 0x1e, 0xae, 0x06, 0xd9, 0x35, 0xb8, 0xea, 0xde, 0xf1, 0xbc, 0xf6, 0x77,
		0x85, 0xd7, 0x18, 0x36, 0xe2, 0xb5, 0x6d, 0x38, 0xc9, 0x19, 0x8f, 0x37, 0xae, 0x7f, 0x4f, 0x24,
		0x56, 0x86, 0xde, 0x89, 0x8e, 0xee, 0x8f, 0xc0, 0xbc, 0xef, 0x4e, 0x51, 0x9e, 0xba, 0x4a, 0x47,
		0xb5, 0xc7, 0x60, 0xfe, 0x65, 0xce, 0x2c, 0x32, 0xbe, 0x5f, 0xdf, 0xba, 0x1b, 0xaa, 0x4d, 0xc8,
		0x5f, 0x83, 0xa2, 0x20, 0xef, 0x9a, 0x0e, 0xd6, 0xac, 0xb6, 0xa9, 0xbf, 0x85, 0x5b, 0x63, 0x50,
		0xff, 0x4a, 0xcf, 0x50, 0xed, 0x84, 0xe0, 0x84, 0x79, 0x0d, 0x24, 0xbf, 0x56, 0x51, 0xf4, 0x8e,
		0x6d, 0x39, 0xde, 0x08, 0xc6, 0x2f, 0x89, 0x91, 0xf2, 0x71, 0x6b, 0x14, 0x56, 0xae, 0x03, 0x7b,
		0x52, 0x3d, 0x6e, 0x48, 0x7e, 0x99, 0x13, 0x4d, 0x07, 0x28, 0x9e, 0x38, 0x34, 0xab, 0x63, 0xab,
		0xce, 0x38, 0xf9, 0xef, 0xef, 0x8b, 0xc4, 0xc1, 0x21, 0x3c, 0x71, 0x90, 0x8a, 0x8e, 0xac, 0xf6,
		0x63, 0x30, 0x7c, 0x45, 0x24, 0x0e, 0x81, 0xe1, 0x14, 0xa2, 0x60, 0x18, 0x83, 0xe2, 0x1f, 0x08,
		0x0a, 0x81, 0x21, 0x14, 0xaf, 0x04, 0x0b, 0xad, 0x83, 0xdb, 0xba, 0xeb, 0x39, 0xac, 0x28, 0x3e,
		0x9a, 0xea, 0x1f, 0x7e, 0x27, 0x5a, 0x84, 0xc9, 0x21, 0x28, 0xc9, 0x44, 0xfc, 0x98, 0x96, 0xee,
		0x99, 0x46, 0x1b, 0xf6, 0xab, 0x22, 0x13, 0x85, 0x60, 0xc4, 0xb6, 0x50, 0x85, 0x48, 0xdc, 0xae,
		0x91, 0x9d, 0xc2, 0x18, 0x74, 0xff, 0xa8, 0xc7, 0xb8, 0xa6, 0xc0, 0x12, 0xce, 0x50, 0xfd, 0xd3,
		0x35, 0x0f, 0xf0, 0xe1, 0x58, 0xd1, 0xf9, 0x6b, 0x3d, 0xf5, 0xcf, 0x0e, 0x43, 0xb2, 0x1c, 0x52,
		0xe8, 0xa9, 0xa7, 0xd0, 0xa8, 0xf7, 0x92, 0x8a, 0x3f, 0xf1, 0x01, 0xef, 0x6f, 0xb4, 0x9c, 0x2a,
		0xaf, 0x93, 0x20, 0x8f, 0x16, 0x3d, 0xa3, 0xc9, 0x3e, 0xfa, 0x81, 0x1f, 0xe7, 0x91, 0x9a, 0xa7,
		0x7c, 0x15, 0xa6, 0x23, 0x05, 0xcf, 0x68, 0xaa, 0x3f, 0xcb, 0xa9, 0x72, 0xe1, 0x7a, 0xa7, 0x7c,
		0x01, 0x92, 0xa4, 0x78, 0x19, 0x0d, 0xff, 0x73, 0x1c, 0x4e, 0xd5, 0xcb, 0x1f, 0x81, 0xb4, 0x28,
		0x5a, 0x46, 0x43, 0xff, 0x3c, 0x87, 0xfa, 0x10, 0x02, 0x17, 0x05, 0xcb, 0x68, 0xf8, 0x5f, 0x10,
		0x70, 0x01, 0x21, 0xf0, 0xf1, 0x5d, 0xf8, 0xd5, 0xbf, 0x98, 0xe4, 0x8b, 0x8e, 0xf0, 0xdd, 0x15,
		0x98, 0xe2, 0x95, 0xca, 0x68, 0xf4, 0xc7, 0xf9, 0xcd, 0x05, 0xa2, 0x7c, 0x09, 0x26, 0xc7, 0x74,
		0xf8, 0x5f, 0xe2, 0x50, 0xa6, 0x5f, 0xae, 0x42, 0x36, 0x54, 0x9d, 0x8c, 0x86, 0xff, 0x24, 0x87,
		0x87, 0x51, 0xc4, 0x74, 0x5e, 0x9d, 0x8c, 0x26, 0xf8, 0xcb, 0xc2, 0x74, 0x8e, 0x20, 0x6e, 0x13,
		0x85, 0xc9, 0x68, 0xf4, 0x27, 0x84, 0xd7, 0x05, 0xa4, 0xfc, 0x12, 0x64, 0xfc, 0xc5, 0x66, 0x34,
		0xfe, 0xa7, 0x38, 0x3e, 0xc0, 0x10, 0x0f, 0x84, 0x16, 0xbb, 0xd1, 0x14, 0x3f, 0x2d, 0x3c, 0x10,
		0x42, 0x91, 0x69, 0xd4, 0x5b, 0xc0, 0x8c, 0x66, 0xfa, 0x19, 0x31, 0x8d, 0x7a, 0xea, 0x17, 0x32,
		0x9a, 0x34, 0xe7, 0x8f, 0xa6, 0xf8, 0x2b, 0x62, 0x34, 0xa9, 0x3e, 0x31, 0xa3, 0xb7, 0x22, 0x18,
		0xcd, 0xf1, 0xb3, 0xc2, 0x8c, 0x9e, 0x82, 0xa0, 0xdc, 0x00, 0xd4, 0x5f, 0x0d, 0x8c, 0xe6, 0xfb,
		0x24, 0xe7, 0x9b, 0xe9, 0x2b, 0x06, 0xca, 0xaf, 0xc2, 0xc9, 0xc1, 0x95, 0xc0, 0x68, 0xd6, 0x9f,
		0xfb, 0xa0, 0x67, 0xef, 0x16, 0x2e, 0x04, 0xca, 0xdb, 0xc1, 0x92, 0x12, 0xae, 0x02, 0x46, 0xd3,
		0x7e, 0xea, 0x83, 0x68, 0xe2, 0x0e, 0x17, 0x01, 0xe5, 0x15, 0x80, 0x60, 0x01, 0x1e, 0xcd, 0xf5,
		0x69, 0xce, 0x15, 0x02, 0x91, 0xa9, 0xc1, 0xd7, 0xdf, 0xd1, 0xf8, 0xbb, 0x62, 0x6a, 0x70, 0x04,
		0x99, 0x1a, 0x62, 0xe9, 0x1d, 0x8d, 0xfe, 0x8c, 0x98, 0x1a, 0x02, 0x42, 0x22, 0x3b, 0xb4, 0xba,
		0x8d, 0x66, 0xf8, 0xac, 0x88, 0xec, 0x10, 0xaa, 0xbc, 0x09, 0x33, 0x7d, 0x0b, 0xe2, 0x68, 0xaa,
		0x5f, 0xe0, 0x54, 0x52, 0xef, 0x7a, 0x18, 0x5e, 0xbc, 0xf8, 0x62, 0x38, 0x9a, 0xed, 0x73, 0x3d,
		0x8b, 0x17, 0x5f, 0x0b, 0xcb, 0x57, 0x20, 0x6d, 0x76, 0x0d, 0x83, 0x4c, 0x1e, 0x74, 0xf4, 0xbb,
		0x84, 0xc5, 0xff, 0xfa, 0x3d, 0xee, 0x1d, 0x01, 0x28, 0x5f, 0x80, 0x49, 0xdc, 0xd9, 0xc5, 0xad,
		0x51, 0xc8, 0x6f, 0x7f, 0x4f, 0x24, 0x4c, 0xa2, 0x5d, 0x7e, 0x09, 0x80, 0x1d, 0x8d, 0xd0, 0x87,
		0x87, 0x23, 0xb0, 0xff, 0xed, 0x7b, 0xfc, 0xe5, 0x9d, 0x00, 0x12, 0x10, 0xb0, 0x57, 0x81, 0x8e,
		0x26, 0xf8, 0x4e, 0x94, 0x80, 0x8e, 0xc8, 0x65, 0x98, 0x7a, 0xd3, 0xb5, 0x4c, 0x4f, 0x6d, 0x8f,
		0x42, 0xff, 0x77, 0x8e, 0x16, 0xfa, 0xc4, 0x61, 0x1d, 0xcb, 0xc1, 0x9e, 0xda, 0x76, 0x47, 0x61,
		0xff, 0x07, 0xc7, 0xfa, 0x00, 0x02, 0xd6, 0x54, 0xd7, 0x1b, 0xa7, 0xdf, 0xbf, 0x27, 0xc0, 0x02,
		0x40, 0x8c, 0x26, 0xff, 0x1f, 0xe0, 0xc3, 0x51, 0xd8, 0xdf, 0x17, 0x46, 0x73, 0xfd, 0xf2, 0x47,
		0x20, 0x43, 0xfe, 0x65, 0x6f, 0xe4, 0x8d, 0x00, 0xff, 0x4f, 0x0e, 0x0e, 0x10, 0xe4, 0xce, 0xae,
		0xd7, 0xf2, 0xf4, 0xd1, 0xce, 0xfe, 0x2e, 0x1f, 0x69, 0xa1, 0x5f, 0x5e, 0x81, 0xac, 0xeb, 0xb5,
		0x5a, 0x5d, 0x5e, 0x9f, 0x8e, 0x80, 0xff, 0xc1, 0xf7, 0xfc, 0x23, 0x0b, 0x1f, 0x43, 0x46, 0xfb,
		0xd6, 0x81, 0x67, 0x5b, 0xf4, 0x81, 0xc7, 0x28, 0x86, 0x0f, 0x38, 0x43, 0x08, 0x52, 0xae, 0x42,
		0x8e, 0xf4, 0xc5, 0xc1, 0x36, 0xa6, 0x4f, 0xa7, 0x46, 0x50, 0xfc, 0x2f, 0xee, 0x80, 0x08, 0xa8,
		0xf2, 0xa3, 0x5f, 0x7b, 0x6f, 0x21, 0xf6, 0x8d, 0xf7, 0x16, 0x62, 0xbf, 0xfb, 0xde, 0x42, 0xec,
		0x13, 0xdf, 0x5c, 0x98, 0xf8, 0xc6, 0x37, 0x17, 0x26, 0x7e, 0xfb, 0x9b, 0x0b, 0x13, 0x83, 0x4f,
		0x89, 0x61, 0xd5, 0x5a, 0xb5, 0xd8, 0xf9, 0xf0, 0x1b, 0xa5, 0xb6, 0xee, 0xed, 0x77, 0x77, 0x97,
		0x35, 0xab, 0x43, 0x8f, 0x71, 0x83, 0xd3, 0x5a, 0x7f, 0x93, 0x03, 0xdf, 0x8f, 0x91, 0x0d, 0x73,
		0xf4, 0x2c, 0x57, 0x35, 0x0f, 0x87, 0x7d, 0xdb, 0x73, 0x11, 0x12, 0x2b, 0xe6, 0x21, 0x3a, 0xcd,
		0xb2, 0x9b, 0xd2, 0x75, 0x0c, 0xfe, 0x4e, 0xd8, 0x14, 0xb9, 0xde, 0x71, 0x0c, 0x34, 0x17, 0xbc,
		0xb8, 0x19, 0x3b, 0x9b, 0xe3, 0x6f, 0x63, 0x56, 0x7e, 0x32, 0x76, 0xbc, 0x6e, 0xa4, 0x57, 0xcc,
		0x43, 0xda, 0x8b, 0x46, 0xec, 0x8d, 0xa7, 0x47, 0x1e, 0x72, 0x1f, 0x98, 0xd6, 0x2d, 0x93, 0x98,
		0x6d, 0xef, 0x8a, 0x03, 0xee, 0x85, 0xde, 0x03, 0xee, 0x57, 0xb1, 0x61, 0x5c, 0x27, 0x7a, 0xdb,
		0x04, 0xb2, 0x9b, 0x62, 0xaf, 0x1f, 0xc3, 0xcf, 0xc4, 0x61, 0xa1, 0xef, 0x2c, 0x9b, 0x47, 0xc0,
		0x30, 0x27, 0x94, 0x21, 0x5d, 0x13, 0x81, 0x55, 0x84, 0x29, 0x17, 0x6b, 0x96, 0xd9, 0x72, 0xa9,
		0x23, 0x12, 0xb2, 0xb8, 0x24, 0x8e, 0x30, 0x55, 0xd3, 0x72, 0xf9, 0x5b, 0x95, 0xec, 0xa2, 0xf2,
		0xf3, 0xc7, 0x74, 0xc4, 0xb4, 0xb8, 0x93, 0xf0, 0xc6, 0x73, 0x63, 0x7a, 0x43, 0x74, 0x22, 0x72,
		0xec, 0x3f, 0xae, 0x57, 0x7e, 0x36, 0x0e, 0x8b, 0xbd, 0x5e, 0x21, 0xd3, 0xca, 0xf5, 0xd4, 0x8e,
		0x3d, 0xcc, 0x2d, 0x57, 0x20, 0xb3, 0x2d, 0x74, 0x8e, 0xed, 0x97, 0xbb, 0xc7, 0xf4, 0x4b, 0xde,
		0xbf, 0x95, 0x70, 0xcc, 0xf9, 0x31, 0x1d, 0xe3, 0xf7, 0xe3, 0x9e, 0x3c, 0xf3, 0x7f, 0x52, 0x70,
		0x5a, 0xb3, 0xdc, 0x8e, 0xe5, 0x2a, 0xec, 0xf9, 0x08, 0xbb, 0xe0, 0x3e, 0xc9, 0x85, 0x9b, 0x46,
		0x3f, 0x24, 0x29, 0x5d, 0x87, 0xd9, 0x35, 0x92, 0x2a, 0xc8, 0x16, 0x28, 0x78, 0xbc, 0x33, 0xf0,
		0xc5, 0xd3, 0xa5, 0x48, 0xb5, 0xcf, 0x1f, 0x2f, 0x85, 0x45, 0xa5, 0x9f, 0x88, 0x81, 0xd4, 0xd4,
		0x54, 0x43, 0x75, 0xfe, 0x7f, 0xa9, 0xd0, 0x25, 0x00, 0xfa, 0xc1, 0x52, 0xf0, 0x85, 0x51, 0xfe,
		0x7c, 0x71, 0x39, 0xdc, 0xb9, 0x65, 0x76, 0x27, 0xfa, 0xf9, 0x42, 0x86, 0xea, 0x92, 0x7f, 0x9f,
		0x7c, 0x0d, 0x20, 0x68, 0x40, 0x0f, 0xc0, 0xa9, 0x66, 0x75, 0x65, 0x7d, 0x45, 0x56, 0xd8, 0x9b,
		0xf0, 0x9b, 0xcd, 0x46, 0xbd, 0xba, 0x76, 0x75, 0xad, 0x5e, 0x93, 0x26, 0xd0, 0x49, 0x40, 0xe1,
		0x46, 0xff, 0xa5, 0x94, 0x13, 0x30, 0x13, 0x96, 0xb3, 0xd7, 0xe9, 0xe3, 0xa4, 0x4c, 0xd4, 0x3b,
		0xb6, 0x81, 0xe9, 0x73, 0x3f, 0x45, 0x17, 0x5e, 0x1b, 0x5d, 0x81, 0xfc, 0xfa, 0xbf, 0x61, 0xaf,
		0x58, 0xcf, 0x06, 0x70, 0xdf, 0xe7, 0xe5, 0x75, 0x98, 0x51, 0x35, 0x0d, 0xdb, 0x11, 0xca, 0x11,
		0x79, 0x9a, 0x10, 0xd2, 0x27, 0x99, 0x1c, 0x19, 0xb0, 0x5d, 0x82, 0x94, 0x4b, 0x7b, 0x3f, 0x8a,
		0xe2, 0xeb, 0x9c, 0x82, 0xab, 0x97, 0x4d, 0x98, 0x21, 0x65, 0x9f, 0xea, 0xe0, 0x90, 0x19, 0x47,
		0x1f, 0x32, 0xfc, 0xe3, 0x2f, 0x3d, 0x4b, 0x9f, 0x6b, 0x3e, 0x1c, 0x1d, 0x96, 0x01, 0xe1, 0x24,
		0x4b, 0x9c, 0x3b, 0x30, 0x14, 0x43, 0x5e, 0xdc, 0x8f, 0x1b, 0x7c, 0xf4, 0xcd, 0xfe, 0x09, 0xbf,
		0xd9, 0xc2, 0xa0, 0x18, 0x08, 0xdd, 0x69, 0x9a, 0xb3, 0xb2, 0x86, 0x4a, 0x7d, 0xd8, 0x9c, 0x7e,
		0xe3, 0xa9, 0xd0, 0xd2, 0xc4, 0x28, 0xf9, 0x9f, 0x67, 0x28, 0xf3, 0x95, 0xf0, 0x6d, 0xfc, 0xb9,
		0xf7, 0x5b, 0x09, 0x58, 0xe0, 0xca, 0xbb, 0xaa, 0x8b, 0xcf, 0xdd, 0x7c, 0x6e, 0x17, 0x7b, 0xea,
		0x73, 0xe7, 0x34, 0x4b, 0x17, 0xb9, 0x7a, 0x96, 0x4f, 0x47, 0xd2, 0xbe, 0xcc, 0xdb, 0xe7, 0x07,
		0x3e, 0xcd, 0x9c, 0x1f, 0x3e, 0x8d, 0x4b, 0x3b, 0x90, 0xac, 0x5a, 0xba, 0x49, 0x52, 0x55, 0x0b,
		0x9b, 0x56, 0x87, 0xcf, 0x1e, 0x76, 0x81, 0x9e, 0x83, 0x94, 0xda, 0xb1, 0xba, 0xa6, 0xc7, 0x66,
		0x4e, 0xe5, 0xf4, 0xd7, 0xde, 0x5d, 0x9c, 0xf8, 0xb7, 0xef, 0x2e, 0x26, 0xd6, 0x4c, 0xef, 0x37,
		0xbf, 0xfc, 0x0c, 0x70, 0xaa, 0x35, 0xd3, 0x93, 0xb9, 0x62, 0x39, 0xf9, 0xfe, 0x3b, 0x8b, 0xb1,
		0xd2, 0x6b, 0x30, 0x55, 0xc3, 0xda, 0xbd, 0x30, 0xd7, 0xb0, 0x16, 0x62, 0xae, 0x61, 0xad, 0x87,
		0xf9, 0x12, 0xa4, 0xd7, 0x4c, 0x8f, 0xbd, 0xb5, 0xfe, 0x14, 0x24, 0x74, 0x93, 0xbd, 0x08, 0x79,
		0xa4, 0x6d, 0x44, 0x8b, 0x00, 0x6b, 0x58, 0xf3, 0x81, 0x2d, 0xac, 0xf5, 0x02, 0xfb, 0x6f, 0x4d,
		0xb4, 0x2a, 0xb5, 0xdf, 0xfe, 0x4f, 0x0b, 0x13, 0x6f, 0xbf, 0xb7, 0x30, 0x31, 0x74, 0x88, 0x4b,
		0x43, 0x87, 0xd8, 0x6d, 0x1d, 0xb0, 0x8c, 0xec, 0x8f, 0xec, 0x17, 0x92, 0xf0, 0x10, 0xfd, 0x98,
		0xc9, 0xe9, 0xe8, 0xa6, 0x77, 0x4e, 0x73, 0x0e, 0x6d, 0x8f, 0x96, 0x2b, 0xd6, 0x1e, 0x1f, 0xd8,
		0x99, 0xa0, 0x79, 0x99, 0x35, 0x0f, 0x1e, 0xd6, 0xd2, 0x1e, 0x4c, 0x36, 0x08, 0x8e, 0xb8, 0xd8,
		0xb3, 0x3c, 0xd5, 0xe0, 0xeb, 0x0f, 0xbb, 0x20, 0x52, 0xf6, 0x01, 0x54, 0x9c, 0x49, 0x75, 0xf1,
		0xed, 0x93, 0x81, 0xd5, 0x3d, 0xf6, 0x1e, 0x79, 0x82, 0x16, 0x2e, 0x69, 0x22, 0xa0, 0xaf, 0x8c,
		0xcf, 0xc1, 0xa4, 0xda, 0x65, 0x2f, 0x30, 0x24, 0x48, 0x45, 0x43, 0x2f, 0x4a, 0xd7, 0x61, 0x8a,
		0x3f, 0x46, 0x45, 0x12, 0x24, 0x0e, 0xf0, 0x21, 0xbd, 0x4f, 0x4e, 0x26, 0xff, 0xa2, 0x65, 0x98,
		0xa4, 0xc6, 0xf3, 0x0f, 0x64, 0x8a, 0xcb, 0x7d, 0xd6, 0x2f, 0x53, 0x23, 0x65, 0xa6, 0x56, 0xba,
		0x06, 0xe9, 0x9a, 0xd5, 0xd1, 0x4d, 0x2b, 0xca, 0x96, 0x61, 0x6c, 0xd4, 0x66, 0xbb, 0xcb, 0xa3,
		0x42, 0x66, 0x17, 0xe8, 0x24, 0xa4, 0xd8, 0x77, 0x05, 0xfc, 0x25, 0x0c, 0x7e, 0x55, 0xaa, 0xc2,
		0x14, 0xe5, 0xde, 0xb2, 0x49, 0xf2, 0xf7, 0x5f, 0xe1, 0xcc, 0xf0, 0xaf, 0xcc, 0x38, 0x7d, 0x3c,
		0x30, 0x16, 0x41, 0xb2, 0xa5, 0x7a, 0x2a, 0xef, 0x37, 0xfd, 0xbf, 0xf4, 0xc3, 0x90, 0xe6, 0x24,
		0x2e, 0x3a, 0x0f, 0x09, 0xcb, 0x76, 0xf9, 0x6b, 0x14, 0xf3, 0xc3, 0xba, 0xb2, 0x65, 0x57, 0x92,
		0x24, 0x66, 0x64, 0xa2, 0x5c, 0x91, 0x87, 0x86, 0xc5, 0x8b, 0xa1, 0xb0, 0x08, 0x0d, 0x79, 0xe8,
		0x5f, 0x36, 0xa4, 0x7d, 0xe1, 0xe0, 0x07, 0xcb, 0x67, 0xe3, 0xb0, 0x10, 0x6a, 0xbd, 0x89, 0x1d,
		0x57, 0xb7, 0x4c, 0x16, 0x51, 0x3c, 0x5a, 0x50, 0xc8, 0x48, 0xde, 0x3e, 0x24, 0x5c, 0x3e, 0x02,
		0x89, 0x15, 0xdb, 0x46, 0xf3, 0x90, 0xa6, 0xd7, 0x9a, 0xc5, 0xe2, 0x25, 0x29, 0xfb, 0xd7, 0xa4,
		0xcd, 0xb5, 0xf6, 0xbc, 0x5b, 0xaa, 0xe3, 0x7f, 0x7a, 0x27, 0xae, 0x4b, 0x97, 0x21, 0x53, 0xb5,
		0x4c, 0x17, 0x9b, 0x6e, 0x97, 0x56, 0x36, 0xbb, 0x86, 0xa5, 0x1d, 0x70, 0x06, 0x76, 0x41, 0x1c,
		0xae, 0xda, 0x36, 0x45, 0x26, 0x65, 0xf2, 0x2f, 0x9b, 0xb3, 0x95, 0xe6, 0x50, 0x17, 0x5d, 0x3e,
		0xbe, 0x8b, 0x78, 0x27, 0x7d, 0x1f, 0x7d, 0x3f, 0x06, 0x0f, 0xf6, 0x4f, 0xa8, 0x03, 0x7c, 0xe8,
		0x1e, 0x77, 0x3e, 0xbd, 0x06, 0x99, 0x06, 0xfd, 0xfe, 0xfd, 0x3a, 0x3e, 0x44, 0xf3, 0x30, 0x85,
		0x5b, 0xe7, 0x2f, 0x5c, 0x78, 0xee, 0x32, 0x8b, 0xf6, 0x97, 0x27, 0x64, 0x21, 0x40, 0x0b, 0x90,
		0x71, 0xb1, 0x66, 0x9f, 0xbf, 0x70, 0xf1, 0xe0, 0x39, 0x16, 0x5e, 0x2f, 0x4f, 0xc8, 0x81, 0xa8,
		0x9c, 0x26, 0xbd, 0x7e, 0xff, 0xb3, 0x8b, 0xb1, 0xca, 0x24, 0x24, 0xdc, 0x6e, 0xe7, 0x43, 0x8d,
		0x91, 0x4f, 0x4d, 0xc2, 0x52, 0x18, 0x49, 0xeb, 0xbf, 0x9b, 0xaa, 0xa1, 0xb7, 0xd4, 0xe0, 0x97,
		0x0b, 0xa4, 0x90, 0x0f, 0xa8, 0xc6, 0x90, 0x95, 0xe2, 0x48, 0x4f, 0x96, 0x7e, 0x25, 0x06, 0xb9,
		0x1b, 0x82, 0xb9, 0x89, 0x3d, 0x74, 0x05, 0xc0, 0xbf, 0x93, 0x98, 0x36, 0x0f, 0x2c, 0xf7, 0xde,
		0x6b, 0xd9, 0xc7, 0xc8, 0x21, 0x75, 0x74, 0x89, 0x06, 0xa2, 0x6d, 0xb9, 0xfc, 0x73, 0xac, 0x11,
		0x50, 0x5f, 0x19, 0x3d, 0x0d, 0x88, 0x66, 0x38, 0xe5, 0xa6, 0xe5, 0xe9, 0x66, 0x5b, 0xb1, 0xad,
		0x5b, 0xfc, 0x23, 0xd7, 0x84, 0x2c, 0xd1, 0x96, 0x1b, 0xb4, 0xa1, 0x41, 0xe4, 0xc4, 0xe8, 0x8c,
		0xcf, 0x42, 0x8a, 0x75, 0xb5, 0xd5, 0x72, 0xb0, 0xeb, 0xf2, 0x24, 0x26, 0x2e, 0xd1, 0x15, 0x98,
		0xb2, 0xbb, 0xbb, 0x8a, 0xc8, 0x18, 0xd9, 0xf3, 0x0f, 0x0e, 0x9a, 0xff, 0x22, 0x3e, 0x78, 0x06,
		0x48, 0xd9, 0xdd, 0x5d, 0x12, 0x2d, 0x0f, 0x43, 0x6e, 0x80, 0x31, 0xd9, 0x9b, 0x81, 0x1d, 0xf4,
		0x67, 0x17, 0x78, 0x0f, 0x14, 0xdb, 0xd1, 0x2d, 0x47, 0xf7, 0x0e, 0xe9, 0xbb, 0x50, 0x09, 0x59,
		0x12, 0x0d, 0x0d, 0x2e, 0x2f, 0x1d, 0x40, 0xa1, 0x49, 0x8b, 0xb8, 0xc0, 0xf2, 0x0b, 0x81, 0x7d,
		0xb1, 0xd1, 0xf6, 0x0d, 0xb5, 0x2c, 0xde, 0x67, 0x59, 0xe5, 0x95, 0xa1, 0xd1, 0x79, 0xe9, 0xf8,
		0xd1, 0x19, 0x5d, 0xed, 0x7e, 0xef, 0x74, 0x64, 0x72, 0xb2, 0xe0, 0x0c, 0xa7, 0xaf, 0x71, 0x03,
		0x73, 0xd4, 0x1e, 0x6d, 0xfe, 0xe8, 0x45, 0x75, 0x7e, 0x44, 0x1a, 0x9d, 0x1f, 0x39, 0x85, 0x4a,
		0x97, 0x61, 0xba, 0xa1, 0x3a, 0x5e, 0x13, 0x7b, 0x2f, 0x63, 0xb5, 0x85, 0x9d, 0xe8, 0xaa, 0x3b,
		0x2d, 0x56, 0x5d, 0x04, 0x49, 0xba, 0xb4, 0xb2, 0x55, 0x87, 0xfe, 0x5f, 0xda, 0x87, 0x24, 0x7d,
		0x1f, 0xd2, 0x5f, 0x91, 0x39, 0x82, 0xad, 0xc8, 0x24, 0x97, 0x1e, 0x7a, 0xd8, 0x15, 0xc7, 0x08,
		0xf4, 0x02, 0xbd, 0x20, 0xd6, 0xd5, 0xc4, 0xd1, 0xeb, 0x2a, 0x0f, 0x44, 0xbe, 0xba, 0x1a, 0x30,
		0x55, 0x21, 0xa9, 0x78, 0xad, 0xe6, 0x1b, 0x12, 0x0b, 0x0c, 0x41, 0x1b, 0x50, 0xb0, 0x55, 0xc7,
		0xa3, 0x9f, 0x92, 0xec, 0xd3, 0x5e, 0xf0, 0x58, 0x5f, 0xec, 0x9f, 0x79, 0x91, 0xce, 0xf2, 0xbb,
		0x4c, 0xdb, 0x61, 0x61, 0xe9, 0x3f, 0x27, 0x21, 0xc5, 0x9d, 0xf1, 0x11, 0x98, 0xe2, 0x6e, 0xe5,
		0xd1, 0xf9, 0xd0, 0x72, 0xff, 0xc2, 0xb4, 0xec, 0x2f, 0x20, 0x9c, 0x4f, 0x60, 0xd0, 0xe3, 0x90,
		0xd6, 0xf6, 0x55, 0xdd, 0x54, 0xf4, 0x16, 0x2f, 0x08, 0xb3, 0xef, 0xbd, 0xbb, 0x38, 0x55, 0x25,
		0xb2, 0xb5, 0x9a, 0x3c, 0x45, 0x1b, 0xd7, 0x5a, 0xa4, 0x12, 0xd8, 0xc7, 0x7a, 0x7b, 0xdf, 0xe3,
		0x33, 0x8c, 0x5f, 0xa1, 0x17, 0x21, 0x49, 0x02, 0x82, 0x7f, 0x68, 0x38, 0xdf, 0x57, 0xe1, 0xfb,
		0x5b, 0xe8, 0x4a, 0x9a, 0xdc, 0xf8, 0x13, 0xff, 0x71, 0x31, 0x26, 0x53, 0x04, 0xaa, 0xc2, 0xb4,
		0xa1, 0xba, 0x9e, 0x42, 0x57, 0x30, 0x72, 0xfb, 0x49, 0x4a, 0x71, 0xba, 0xdf, 0x21, 0xdc, 0xb1,
		0xdc, 0xf4, 0x2c, 0x41, 0x31, 0x51, 0x0b, 0x9d, 0x05, 0x89, 0x92, 0x68, 0x56, 0xa7, 0xa3, 0x7b,
		0xac, 0xb6, 0x4a, 0x51, 0xbf, 0xe7, 0x89, 0xbc, 0x4a, 0xc5, 0xb4, 0xc2, 0x7a, 0x00, 0x32, 0xf4,
		0xd3, 0x26, 0xaa, 0xc2, 0x5e, 0xc2, 0x4d, 0x13, 0x01, 0x6d, 0x3c, 0x03, 0x85, 0x20, 0x3f, 0x32,
		0x95, 0x34, 0x63, 0x09, 0xc4, 0x54, 0xf1, 0x59, 0x98, 0x33, 0xf1, 0x6d, 0xfa, 0x5a, 0x70, 0x44,
		0x3b, 0x43, 0xb5, 0x11, 0x69, 0xbb, 0x11, 0x45, 0x3c, 0x06, 0x79, 0x4d, 0x38, 0x9f, 0xe9, 0x02,
		0xd5, 0x9d, 0xf6, 0xa5, 0x54, 0xed, 0x34, 0xa4, 0x55, 0xdb, 0x66, 0x0a, 0x59, 0x9e, 0x1f, 0x6d,
		0x9b, 0x36, 0x3d, 0x09, 0x33, 0xb4, 0x8f, 0x0e, 0x76, 0xbb, 0x86, 0xc7, 0x49, 0x72, 0x54, 0xa7,
		0x40, 0x1a, 0x64, 0x26, 0xa7, 0xba, 0x8f, 0xc0, 0x34, 0xbe, 0xa9, 0xb7, 0xb0, 0xa9, 0x61, 0xa6,
		0x37, 0x4d, 0xf5, 0x72, 0x42, 0x48, 0x95, 0x9e, 0x00, 0x3f, 0xef, 0x29, 0x22, 0x27, 0xe7, 0x19,
		0x9f, 0x90, 0xaf, 0x30, 0x71, 0xa9, 0x08, 0xc9, 0x9a, 0xea, 0xa9, 0xa4, 0xc0, 0xf0, 0x6e, 0xb3,
		0x85, 0x26, 0x27, 0x93, 0x7f, 0x4b, 0xef, 0xc7, 0x21, 0x79, 0xc3, 0xf2, 0x30, 0x7a, 0x3e, 0x54,
		0x00, 0xe6, 0x07, 0xc5, 0x73, 0x53, 0x6f, 0x9b, 0xb8, 0xb5, 0xe1, 0xb6, 0x43, 0xbf, 0x43, 0x10,
		0x84, 0x53, 0x3c, 0x12, 0x4e, 0x73, 0x30, 0xe9, 0x58, 0x5d, 0xb3, 0x25, 0xde, 0x5f, 0xa5, 0x17,
		0xa8, 0x0e, 0x69, 0x3f, 0x4a, 0x92, 0xa3, 0xa2, 0xa4, 0x40, 0xa2, 0x84, 0xc4, 0x30, 0x17, 0xc8,
		0x53, 0xbb, 0x3c, 0x58, 0x2a, 0x90, 0xf1, 0x93, 0x17, 0x8f, 0xb6, 0xf1, 0x02, 0x36, 0x80, 0x91,
		0xc5, 0xc4, 0x1f, 0x7b, 0xdf, 0x79, 0x2c, 0xe2, 0x24, 0xbf, 0x81, 0x7b, 0x2f, 0x12, 0x56, 0xfc,
		0x37, 0x11, 0xa6, 0x68, 0xbf, 0x82, 0xb0, 0x62, 0xbf, 0x8b, 0xf0, 0x20, 0x64, 0x5c, 0xbd, 0x6d,
		0xaa, 0x5e, 0xd7, 0xc1, 0x3c, 0xf2, 0x02, 0x41, 0xe9, 0xab, 0x31, 0x48, 0xb1, 0x48, 0x0e, 0xf9,
		0x2d, 0x36, 0xd8, 0x6f, 0xf1, 0x61, 0x7e, 0x4b, 0xdc, 0xbb, 0xdf, 0x56, 0x00, 0x7c, 0x63, 0x5c,
		0xfe, 0xa9, 0xfa, 0x80, 0x8a, 0x81, 0x99, 0xd8, 0xd4, 0xdb, 0x7c, 0xa2, 0x86, 0x40, 0xa5, 0xff,
		0x10, 0x23, 0x45, 0x2c, 0x6f, 0x47, 0x2b, 0x30, 0x2d, 0xec, 0x52, 0xf6, 0x0c, 0xb5, 0xcd, 0x63,
		0xe7, 0xa1, 0xa1, 0xc6, 0x5d, 0x35, 0xd4, 0xb6, 0x9c, 0xe5, 0xf6, 0x90, 0x8b, 0xc1, 0xe3, 0x10,
		0x1f, 0x32, 0x0e, 0x91, 0x81, 0x4f, 0xdc, 0xdb, 0xc0, 0x47, 0x86, 0x28, 0xd9, 0x3b, 0x44, 0x5f,
		0x8a, 0xd3, 0xcd, 0x8c, 0x6d, 0xb9, 0xaa, 0xf1, 0x83, 0x98, 0x11, 0x0f, 0x40, 0xc6, 0xb6, 0x0c,
		0x85, 0xb5, 0xb0, 0xf7, 0xba, 0xd3, 0xb6, 0x65, 0xc8, 0x7d, 0xc3, 0x3e, 0x79, 0x9f, 0xa6, 0x4b,
		0xea, 0x3e, 0x78, 0x6d, 0xaa, 0xd7, 0x6b, 0x0e, 0xe4, 0x98, 0x2b, 0xf8, 0x5a, 0xf6, 0x2c, 0xf1,
		0x01, 0x5d, 0x1c, 0x63, 0xfd, 0x6b, 0x2f, 0x33, 0x9b, 0x69, 0xca, 0x5c, 0x8f, 0x20, 0x58, 0xea,
		0x1f, 0xb4, 0x0b, 0x0e, 0x87, 0xa5, 0xcc, 0xf5, 0x4a, 0x7f, 0x35, 0x06, 0xb0, 0x4e, 0x3c, 0x4b,
		0xfb, 0x4b, 0x56, 0x21, 0x97, 0x9a, 0xa0, 0x44, 0xee, 0xbc, 0x30, 0x6c, 0xd0, 0xf8, 0xfd, 0x73,
		0x6e, 0xd8, 0xee, 0x2a, 0x4c, 0x07, 0xc1, 0xe8, 0x62, 0x61, 0xcc, 0xc2, 0x11, 0x55, 0x75, 0x13,
		0x7b, 0x72, 0xee, 0x66, 0xe8, 0xaa, 0xf4, 0xcf, 0x63, 0x90, 0xa1, 0x36, 0x6d, 0x60, 0x4f, 0x8d,
		0x8c, 0x61, 0xec, 0xde, 0xc7, 0xf0, 0x21, 0x00, 0x46, 0xe3, 0xea, 0x6f, 0x61, 0x1e, 0x59, 0x19,
		0x2a, 0x69, 0xea, 0x6f, 0x61, 0x74, 0xd1, 0x77, 0x78, 0xe2, 0x68, 0x87, 0x8b, 0xaa, 0x9b, 0xbb,
		0xfd, 0x14, 0x4c, 0xd1, 0x9f, 0x76, 0xba, 0xed, 0xf2, 0x42, 0x3a, 0x65, 0x76, 0x3b, 0xdb, 0xb7,
		0xdd, 0xd2, 0x9b, 0x30, 0xb5, 0x7d, 0x9b, 0x9d, 0x8d, 0x3c, 0x00, 0x19, 0xc7, 0xb2, 0xf8, 0x9a,
		0xcc, 0x6a, 0xa1, 0x34, 0x11, 0xd0, 0x25, 0x48, 0x9c, 0x07, 0xc4, 0x83, 0xf3, 0x80, 0xe0, 0x40,
		0x23, 0x31, 0xd6, 0x81, 0xc6, 0x93, 0xbf, 0x15, 0x83, 0x6c, 0x28, 0x3f, 0xa0, 0xe7, 0xe0, 0x44,
		0x65, 0x7d, 0xab, 0x7a, 0x5d, 0x59, 0xab, 0x29, 0x57, 0xd7, 0x57, 0x56, 0x83, 0x2f, 0x97, 0xe6,
		0x4f, 0xde, 0xb9, 0xbb, 0x84, 0x42, 0xba, 0x3b, 0x26, 0x3d, 0xa7, 0x47, 0xe7, 0x60, 0x2e, 0x0a,
		0x59, 0xa9, 0x34, 0xeb, 0x9b, 0xdb, 0x52, 0x6c, 0xfe, 0xc4, 0x9d, 0xbb, 0x4b, 0x33, 0x21, 0xc4,
		0xca, 0xae, 0x8b, 0x4d, 0xaf, 0x1f, 0x50, 0xdd, 0xda, 0xd8, 0x58, 0xdb, 0x96, 0xe2, 0x7d, 0x00,
		0x9e, 0xb0, 0x9f, 0x80, 0x99, 0x28, 0x60, 0x73, 0x6d, 0x5d, 0x4a, 0xcc, 0xa3, 0x3b, 0x77, 0x97,
		0xf2, 0x21, 0xed, 0x4d, 0xdd, 0x98, 0x4f, 0x7f, 0xec, 0x73, 0x0b, 0x13, 0xbf, 0xf4, 0x8b, 0x0b,
		0x31, 0xd2, 0xb3, 0xe9, 0x48, 0x8e, 0x40, 0x4f, 0xc3, 0xa9, 0xe6, 0xda, 0xea, 0x66, 0xbd, 0xa6,
		0x6c, 0x34, 0x57, 0xc5, 0x49, 0xb7, 0xe8, 0x5d, 0xe1, 0xce, 0xdd, 0xa5, 0x2c, 0xef, 0xd2, 0x30,
		0xed, 0x86, 0x5c, 0xbf, 0xb1, 0xb5, 0x5d, 0x97, 0x62, 0x4c, 0xbb, 0xe1, 0xe0, 0x9b, 0x96, 0xc7,
		0x7e, 0xfb, 0xed, 0x59, 0x38, 0x3d, 0x40, 0xdb, 0xef, 0xd8, 0xcc, 0x9d, 0xbb, 0x4b, 0xd3, 0x0d,
		0x07, 0xb3, 0xf9, 0x43, 0x11, 0xcb, 0x50, 0xec, 0x47, 0x6c, 0x35, 0xb6, 0x9a, 0x2b, 0xeb, 0xd2,
		0xd2, 0xbc, 0x74, 0xe7, 0xee, 0x52, 0x4e, 0x24, 0x43, 0xa2, 0x1f, 0xf4, 0xec, 0xc3, 0xdc, 0xf1,
		0xbc, 0xff, 0x14, 0x3c, 0xca, 0xcf, 0x00, 0x5d, 0x4f, 0x3d, 0xd0, 0xcd, 0xb6, 0x7f, 0x78, 0xcb,
		0xaf, 0xf9, 0xce, 0xe7, 0x24, 0x3f, 0x67, 0x14, 0xd2, 0x11, 0x47, 0xb8, 0x43, 0x9f, 0x5c, 0xce,
		0x8f, 0x78, 0xa8, 0x37, 0x7a, 0xeb, 0x34, 0xfc, 0x78, 0x78, 0x7e, 0xc4, 0x21, 0xf4, 0xfc, 0x91,
		0x9b, 0xbb, 0xd2, 0xc7, 0x63, 0x90, 0x7f, 0x59, 0x77, 0x3d, 0xcb, 0xd1, 0x35, 0xd5, 0xa0, 0xdf,
		0x2b, 0x5d, 0x1c, 0x37, 0xb7, 0xf6, 0x4c, 0xf5, 0x97, 0x20, 0x75, 0x53, 0x35, 0x58, 0x52, 0x0b,
		0x3f, 0x0b, 0xe8, 0x75, 0x5f, 0x90, 0xda, 0x04, 0x01, 0x83, 0x95, 0xbe, 0x18, 0x87, 0x02, 0x9d,
		0x0c, 0x2e, 0xfb, 0xe9, 0x2e, 0xb2, 0xc7, 0x6a, 0x40, 0xd2, 0x51, 0x3d, 0x7e, 0x68, 0x58, 0xf9,
		0x21, 0x7e, 0x0e, 0xfc, 0xf8, 0xe8, 0xd3, 0xdc, 0xe5, 0xfe, 0xa3, 0x62, 0xca, 0x84, 0x5e, 0x85,
		0x74, 0x47, 0xbd, 0xad, 0x50, 0xd6, 0xf8, 0x7d, 0x60, 0x9d, 0xea, 0xa8, 0xb7, 0x89, 0xad, 0xa8,
		0x05, 0x05, 0x42, 0xac, 0xed, 0xab, 0x66, 0x1b, 0x33, 0xfe, 0xc4, 0x7d, 0xe0, 0x9f, 0xee, 0xa8,
		0xb7, 0xab, 0x94, 0x93, 0xdc, 0xa5, 0x9c, 0xfe, 0xe4, 0x3b, 0x8b, 0x13, 0xf4, 0x98, 0xfd, 0xd7,
		0x62, 0x00, 0x81, 0xbb, 0xd0, 0x9f, 0x04, 0x49, 0xf3, 0xaf, 0xe8, 0xed, 0x5d, 0x3e, 0x80, 0x67,
		0x86, 0x0d, 0x44, 0x8f, 0xb3, 0xd9, 0xc2, 0xfc, 0x8d, 0x77, 0x17, 0x63, 0x72, 0x41, 0xeb, 0x19,
		0x87, 0x3a, 0x64, 0xbb, 0x76, 0x4b, 0xf5, 0xb0, 0x42, 0x37, 0x71, 0xf1, 0x63, 0x2c, 0xf2, 0xc0,
		0x80, 0xa4, 0x29, 0x64, 0xfd, 0x17, 0x63, 0x90, 0xad, 0x85, 0x1e, 0xf2, 0x15, 0x61, 0xaa, 0x63,
		0x99, 0xfa, 0x01, 0x0f, 0xbb, 0x8c, 0x2c, 0x2e, 0xd1, 0x3c, 0xa4, 0xd9, 0x97, 0x9a, 0xde, 0xa1,
		0x38, 0xf1, 0x14, 0xd7, 0x04, 0x75, 0x0b, 0xef, 0xba, 0xba, 0xf0, 0xb5, 0x2c, 0x2e, 0xc9, 0xd6,
		0xc5, 0xc5, 0x5a, 0xd7, 0xd1, 0xbd, 0x43, 0x45, 0xb3, 0x4c, 0x4f, 0xd5, 0x3c, 0xfe, 0xcd, 0x5f,
		0x41, 0xc8, 0xab, 0x4c, 0x4c, 0x48, 0x5a, 0xd8, 0x53, 0x75, 0xc3, 0x2d, 0xb2, 0x07, 0x61, 0xe2,
		0x32, 0x64, 0xee, 0xaf, 0xa7, 0xc2, 0x47, 0x54, 0x55, 0x90, 0x2c, 0x1b, 0x3b, 0x91, 0x92, 0x92,
		0x45, 0x68, 0xf1, 0x37, 0xbf, 0xfc, 0xcc, 0x1c, 0x77, 0x37, 0x2f, 0x2a, 0xd9, 0x4b, 0xad, 0x72,
		0x41, 0x20, 0x44, 0xad, 0xf9, 0x3a, 0x19, 0x30, 0xb1, 0xdf, 0xb3, 0xbb, 0xbb, 0xc1, 0xb1, 0xd6,
		0x5c, 0x9f, 0x5f, 0x57, 0xcc, 0xc3, 0x4a, 0xf1, 0xeb, 0x01, 0x75, 0x70, 0x96, 0x74, 0x1d, 0x1f,
		0x92, 0xd1, 0xe2, 0x3c, 0x0d, 0x4a, 0x43, 0x4a, 0xc4, 0x37, 0x55, 0xdd, 0x10, 0x1f, 0xa0, 0xcb,
		0xfc, 0x0a, 0x95, 0x21, 0xe5, 0x7a, 0xaa, 0xd7, 0x75, 0xf9, 0x0f, 0xcb, 0x95, 0x86, 0x45, 0x46,
		0xc5, 0x32, 0x5b, 0x4d, 0xaa, 0x29, 0x73, 0x04, 0xda, 0x86, 0x94, 0x67, 0x1d, 0x60, 0x93, 0x3b,
		0xe9, 0x58, 0x51, 0x3d, 0xe0, 0x59, 0x14, 0xe3, 0x42, 0x6d, 0x90, 0x5a, 0xd8, 0xc0, 0x6d, 0x56,
		0x10, 0xed, 0xab, 0x64, 0xdf, 0x90, 0xba, 0x0f, 0xb3, 0xa6, 0xe0, 0xb3, 0x36, 0x29, 0x29, 0xba,
		0x1e, 0x7d, 0xcc, 0xcc, 0x7e, 0x85, 0xf1, 0x91, 0x61, 0xfd, 0x0f, 0x45, 0xa6, 0x38, 0x4c, 0x08,
		0x3f, 0x91, 0x7e, 0x02, 0xa4, 0xae, 0xb9, 0x6b, 0x99, 0xf4, 0x33, 0x51, 0x5e, 0x8c, 0xa7, 0x69,
		0x79, 0x53, 0xf0, 0xe5, 0x2f, 0xb3, 0xaa, 0xfc, 0x3a, 0xe4, 0x03, 0x55, 0x3a, 0x77, 0x32, 0xc7,
		0x98, 0x3b, 0xd3, 0x3e, 0x96, 0xb4, 0xa2, 0x97, 0x01, 0x82, 0x89, 0x49, 0x8f, 0x07, 0xb2, 0xc3,
		0xc7, 0x30, 0x98, 0xdd, 0x62, 0x9b, 0x15, 0x60, 0x91, 0x01, 0xb3, 0x1d, 0xdd, 0x54, 0x5c, 0x6c,
		0xec, 0x29, 0xdc, 0x55, 0x84, 0x32, 0x7b, 0x1f, 0x86, 0x76, 0xa6, 0xa3, 0x9b, 0x4d, 0x6c, 0xec,
		0xd5, 0x7c, 0xda, 0x72, 0xee, 0x63, 0xef, 0x2c, 0x4e, 0xf0, 0xb9, 0x34, 0x51, 0x6a, 0xd0, 0x23,
		0x6a, 0x3e, 0x0d, 0xb0, 0x8b, 0x2e, 0x42, 0x46, 0x15, 0x17, 0xf4, 0xe0, 0xe0, 0xa8, 0x69, 0x14,
		0xa8, 0xb2, 0xd9, 0xf9, 0xf6, 0xbf, 0x5f, 0x8a, 0x95, 0x7e, 0x31, 0x06, 0xa9, 0xda, 0x8d, 0x86,
		0xaa, 0x3b, 0xa8, 0x0e, 0x33, 0x41, 0x40, 0x8d, 0x3b, 0x37, 0x83, 0x18, 0x14, 0x93, 0xb3, 0x3e,
		0x6c, 0xd7, 0x78, 0x24, 0x4d, 0xef, 0x7e, 0xb2, 0xa7, 0xe3, 0x75, 0x98, 0x62, 0x56, 0xba, 0xa8,
		0x0c, 0x93, 0x36, 0xf9, 0x87, 0x9f, 0xc8, 0x2f, 0x0c, 0x0d, 0x44, 0xaa, 0xef, 0x9f, 0x20, 0x12,
		0x48, 0xe9, 0xfb, 0x31, 0x80, 0xda, 0x8d, 0x1b, 0xdb, 0x8e, 0x6e, 0x1b, 0xd8, 0xbb, 0x5f, 0x3d,
		0x5e, 0x87, 0x13, 0xa1, 0xad, 0x89, 0xa3, 0x8d, 0xdd, 0xeb, 0xd9, 0x60, 0x73, 0xe2, 0x68, 0x03,
		0xd9, 0x5a, 0xae, 0xe7, 0xb3, 0x25, 0xc6, 0x66, 0xab, 0xb9, 0xde, 0x60, 0x37, 0x36, 0x21, 0x1b,
		0x74, 0xdf, 0x45, 0x35, 0x48, 0x7b, 0xfc, 0x7f, 0xee, 0xcd, 0xd2, 0x70, 0x6f, 0x0a, 0x18, 0xf7,
		0xa8, 0x8f, 0x2c, 0xfd, 0x5f, 0xe2, 0x54, 0x3f, 0x62, 0xff, 0x68, 0x85, 0x11, 0xc9, 0xbd, 0x3c,
		0x37, 0xde, 0x8f, 0x8a, 0x82, 0x73, 0xf5, 0x78, 0xf5, 0xa3, 0x71, 0x98, 0xdd, 0x11, 0xd9, 0xe6,
		0x8f, 0xac, 0x27, 0x1a, 0x30, 0x85, 0x4d, 0xcf, 0xd1, 0xa9, 0x2b, 0xc8, 0x58, 0x3f, 0x3b, 0x6c,
		0xac, 0x07, 0xf4, 0x85, 0xfe, 0xbe, 0x91, 0x38, 0xd7, 0xe6, 0x34, 0x3d, 0x5e, 0xf8, 0x77, 0x71,
		0x28, 0x0e, 0x43, 0xa2, 0x33, 0x50, 0xd0, 0x1c, 0x4c, 0x05, 0x4a, 0xe4, 0x70, 0x2d, 0x2f, 0xc4,
		0x3c, 0xe9, 0x6f, 0x00, 0x29, 0xa0, 0x48, 0x60, 0x11, 0xd5, 0x63, 0x57, 0x4c, 0xf9, 0x00, 0x4c,
		0xd3, 0x3e, 0x86, 0x82, 0x6e, 0xea, 0x9e, 0xae, 0x1a, 0xca, 0xae, 0x6a, 0xa8, 0xa6, 0x76, 0x2f,
		0x95, 0x65, 0x7f, 0xa2, 0xce, 0x73, 0xd2, 0x0a, 0xe3, 0x44, 0x37, 0x60, 0x4a, 0xd0, 0x27, 0xef,
		0x03, 0xbd, 0x20, 0x0b, 0x55, 0x51, 0xbf, 0x13, 0x87, 0x19, 0x19, 0xb7, 0xfe, 0x78, 0xb9, 0xf5,
		0x47, 0x00, 0xd8, 0x84, 0x23, 0x79, 0xf0, 0x1e, 0x3c, 0xdb, 0x3f, 0x81, 0x33, 0x8c, 0xaf, 0xe6,
		0x7a, 0x21, 0xdf, 0x7e, 0x3d, 0x0e, 0xb9, 0xb0, 0x6f, 0xff, 0x18, 0xac, 0x0b, 0x68, 0x2d, 0xc8,
		0x06, 0x49, 0xfe, 0xcb, 0xac, 0x43, 0xb2, 0x41, 0x5f, 0xd4, 0x1d, 0x9d, 0x06, 0xbe, 0x1b, 0x87,
		0x54, 0x43, 0x75, 0xd4, 0x8e, 0x8b, 0xae, 0xf5, 0x15, 0x70, 0xe2, 0x94, 0xad, 0xef, 0xf7, 0xb7,
		0xf9, 0xa6, 0x9e, 0x85, 0xdc, 0x27, 0x07, 0xd4, 0x6f, 0x8f, 0x41, 0x9e, 0x6c, 0x11, 0x43, 0x0f,
		0xe4, 0xe3, 0xf4, 0x31, 0x23, 0xd9, 0xe3, 0x05, 0x4f, 0x83, 0xd0, 0x22, 0x64, 0x89, 0x5a, 0x90,
		0xe8, 0x88, 0x0e, 0x74, 0xd4, 0xdb, 0x75, 0x26, 0x41, 0xcf, 0x00, 0xda, 0xf7, 0x37, 0xed, 0x4a,
		0xe0, 0x02, 0xa2, 0x37, 0x13, 0xb4, 0x08, 0xf5, 0x87, 0x00, 0x88, 0x15, 0x0a, 0x7b, 0xc9, 0x8b,
		0xed, 0x71, 0x32, 0x44, 0x52, 0xa3, 0x2f, 0x7a, 0xfd, 0x38, 0xab, 0x05, 0x7b, 0x76, 0x8f, 0xbc,
		0x0c, 0x5f, 0x3f, 0x5e, 0xa4, 0x7e, 0xf7, 0xdd, 0xc5, 0xf9, 0x43, 0xb5, 0x63, 0x94, 0x4b, 0x03,
		0x28, 0x4b, 0xb4, 0x36, 0x8c, 0xee, 0x3a, 0x43, 0x11, 0xfc, 0xb9, 0x18, 0xa0, 0x20, 0xe5, 0xca,
		0xd8, 0xb5, 0xc9, 0xb6, 0x86, 0x14, 0xbd, 0xa1, 0x0a, 0x35, 0x76, 0x74, 0xd1, 0x1b, 0xe0, 0x45,
		0xd1, 0x1b, 0x9a, 0x11, 0x97, 0x83, 0x04, 0x17, 0xe7, 0x63, 0x38, 0xe0, 0x0d, 0xbd, 0xe5, 0xaa,
		0xa5, 0x0b, 0x74, 0x5f, 0x0e, 0x9b, 0x28, 0xfd, 0x4e, 0x0c, 0x4e, 0xf7, 0x45, 0x93, 0x6f, 0xec,
		0x9f, 0x02, 0xe4, 0x84, 0x1a, 0xf9, 0x4f, 0xec, 0x31, 0xa3, 0x8f, 0x1d, 0x9c, 0x33, 0x4e, 0x5f,
		0xae, 0xfc, 0xb0, 0x72, 0x34, 0x7b, 0x73, 0xef, 0x9f, 0xc6, 0x60, 0x2e, 0x6c, 0x8c, 0xdf, 0xad,
		0x4d, 0xc8, 0x85, 0x6d, 0xe1, 0x1d, 0x7a, 0x74, 0x9c, 0x0e, 0xf1, 0xbe, 0x44, 0xf0, 0xe8, 0x95,
		0x60, 0xe2, 0xb2, 0xc3, 0xa2, 0xe7, 0xc6, 0xf6, 0x8d, 0xb0, 0xa9, 0x77, 0x02, 0x27, 0x45, 0x15,
		0x93, 0x6c, 0x58, 0x96, 0x81, 0xfe, 0x34, 0xcc, 0x98, 0x96, 0xa7, 0x90, 0x28, 0xc7, 0x2d, 0x85,
		0xef, 0x5c, 0x59, 0xf6, 0x7b, 0xe5, 0x78, 0x2e, 0xfb, 0xf6, 0xbb, 0x8b, 0xfd, 0x54, 0x3d, 0x7e,
		0x2c, 0x98, 0x96, 0x57, 0xa1, 0xed, 0xdb, 0x6c, 0x5f, 0xeb, 0xc0, 0x74, 0xf4, 0xd6, 0x2c, 0x5b,
		0x6e, 0x1c, 0xfb, 0xd6, 0xd3, 0x47, 0xdd, 0x36, 0xb7, 0x1b, 0xba, 0x27, 0x7b, 0xa7, 0xe9, 0xf7,
		0xdf, 0x59, 0x8c, 0x3d, 0xf9, 0x95, 0x18, 0x40, 0xb0, 0x85, 0x47, 0x4f, 0xc3, 0xa9, 0xca, 0xd6,
		0x66, 0x4d, 0x69, 0x6e, 0xaf, 0x6c, 0xef, 0x34, 0xa3, 0x6f, 0x3e, 0x8b, 0x33, 0x61, 0xd7, 0xc6,
		0x1a, 0xfd, 0x01, 0x42, 0xf4, 0x38, 0xcc, 0x45, 0xb5, 0xc9, 0x55, 0xbd, 0x26, 0xc5, 0xe6, 0x73,
		0x77, 0xee, 0x2e, 0xa5, 0x59, 0x75, 0x84, 0x5b, 0xe8, 0x2c, 0x9c, 0xe8, 0xd7, 0x5b, 0xdb, 0x5c,
		0x95, 0xe2, 0xf3, 0xd3, 0x77, 0xee, 0x2e, 0x65, 0xfc, 0x32, 0x0a, 0x95, 0x00, 0x85, 0x35, 0x39,
		0x5f, 0x62, 0x1e, 0xee, 0xdc, 0x5d, 0x4a, 0x31, 0xb7, 0xcd, 0x27, 0x3f, 0xf6, 0xb9, 0x85, 0x89,
		0xca, 0xd5, 0xa1, 0xa7, 0xbe, 0x4f, 0x1f, 0xe9, 0xb1, 0xdb, 0xfe, 0x49, 0x6e, 0xe4, 0xa8, 0xf7,
		0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x7b, 0x72, 0x38, 0x1c, 0x34, 0x66, 0x00, 0x00,
	}
	r := bytes.NewReader(gzipped)
	gzipr, err := compress_gzip.NewReader(r)
	if err != nil {
		panic(err)
	}
	ungzipped, err := io_ioutil.ReadAll(gzipr)
	if err != nil {
		panic(err)
	}
	if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil {
		panic(err)
	}
	return d
}
func (this *CommissionRates) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CommissionRates)
	if !ok {
		that2, ok := that.(CommissionRates)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Rate.Equal(that1.Rate) {
		return false
	}
	if !this.MaxRate.Equal(that1.MaxRate) {
		return false
	}
	if !this.MaxChangeRate.Equal(that1.MaxChangeRate) {
		return false
	}
	return true
}
func (this *Commission) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Commission)
	if !ok {
		that2, ok := that.(Commission)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.CommissionRates.Equal(&that1.CommissionRates) {
		return false
	}
	if !this.UpdateTime.Equal(that1.UpdateTime) {
		return false
	}
	return true
}
func (this *Description) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Description)
	if !ok {
		that2, ok := that.(Description)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Moniker != that1.Moniker {
		return false
	}
	if this.Identity != that1.Identity {
		return false
	}
	if this.Website != that1.Website {
		return false
	}
	if this.SecurityContact != that1.SecurityContact {
		return false
	}
	if this.Details != that1.Details {
		return false
	}
	return true
}
func (this *UnbondingDelegationEntry) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UnbondingDelegationEntry)
	if !ok {
		that2, ok := that.(UnbondingDelegationEntry)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.CreationHeight != that1.CreationHeight {
		return false
	}
	if !this.CompletionTime.Equal(that1.CompletionTime) {
		return false
	}
	if !this.InitialBalance.Equal(that1.InitialBalance) {
		return false
	}
	if !this.Balance.Equal(that1.Balance) {
		return false
	}
	return true
}
func (this *RedelegationEntry) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RedelegationEntry)
	if !ok {
		that2, ok := that.(RedelegationEntry)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.CreationHeight != that1.CreationHeight {
		return false
	}
	if !this.CompletionTime.Equal(that1.CompletionTime) {
		return false
	}
	if !this.InitialBalance.Equal(that1.InitialBalance) {
		return false
	}
	if !this.SharesDst.Equal(that1.SharesDst) {
		return false
	}
	return true
}
func (this *Params) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Params)
	if !ok {
		that2, ok := that.(Params)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.UnbondingTime != that1.UnbondingTime {
		return false
	}
	if this.MaxValidators != that1.MaxValidators {
		return false
	}
	if this.MaxEntries != that1.MaxEntries {
		return false
	}
	if this.HistoricalEntries != that1.HistoricalEntries {
		return false
	}
	if this.BondDenom != that1.BondDenom {
		return false
	}
	if !this.MinCommissionRate.Equal(that1.MinCommissionRate) {
		return false
	}
	return true
}
func (this *RedelegationEntryResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RedelegationEntryResponse)
	if !ok {
		that2, ok := that.(RedelegationEntryResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RedelegationEntry.Equal(&that1.RedelegationEntry) {
		return false
	}
	if !this.Balance.Equal(that1.Balance) {
		return false
	}
	return true
}
func (this *Pool) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Pool)
	if !ok {
		that2, ok := that.(Pool)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.NotBondedTokens.Equal(that1.NotBondedTokens) {
		return false
	}
	if !this.BondedTokens.Equal(that1.BondedTokens) {
		return false
	}
	return true
}
func (m *HistoricalInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HistoricalInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HistoricalInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Valset) > 0 {
		for iNdEx := len(m.Valset) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Valset[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStaking(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *CommissionRates) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CommissionRates) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CommissionRates) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.MaxChangeRate.Size()
		i -= size
		if _, err := m.MaxChangeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.MaxRate.Size()
		i -= size
		if _, err := m.MaxRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.Rate.Size()
		i -= size
		if _, err := m.Rate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Commission) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Commission) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Commission) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdateTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime):])
	if err2 != nil {
		return 0, err2
	}
	i -= n2
	i = encodeVarintStaking(dAtA, i, uint64(n2))
	i--
	dAtA[i] = 0x12
	{
		size, err := m.CommissionRates.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Description) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Description) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Description) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Details) > 0 {
		i -= len(m.Details)
		copy(dAtA[i:], m.Details)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.Details)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.SecurityContact) > 0 {
		i -= len(m.SecurityContact)
		copy(dAtA[i:], m.SecurityContact)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.SecurityContact)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Website) > 0 {
		i -= len(m.Website)
		copy(dAtA[i:], m.Website)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.Website)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Moniker) > 0 {
		i -= len(m.Moniker)
		copy(dAtA[i:], m.Moniker)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.Moniker)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Validator) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Validator) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.MinSelfDelegation.Size()
		i -= size
		if _, err := m.MinSelfDelegation.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	{
		size, err := m.Commission.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x52
	n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime):])
	if err5 != nil {
		return 0, err5
	}
	i -= n5
	i = encodeVarintStaking(dAtA, i, uint64(n5))
	i--
	dAtA[i] = 0x4a
	if m.UnbondingHeight != 0 {
		i = encodeVarintStaking(dAtA, i, uint64(m.UnbondingHeight))
		i--
		dAtA[i] = 0x40
	}
	{
		size, err := m.Description.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size := m.DelegatorShares.Size()
		i -= size
		if _, err := m.DelegatorShares.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.Tokens.Size()
		i -= size
		if _, err := m.Tokens.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.Status != 0 {
		i = encodeVarintStaking(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x20
	}
	if m.Jailed {
		i--
		if m.Jailed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.ConsensusPubkey != nil {
		{
			size, err := m.ConsensusPubkey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStaking(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.OperatorAddress) > 0 {
		i -= len(m.OperatorAddress)
		copy(dAtA[i:], m.OperatorAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.OperatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValAddresses) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValAddresses) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValAddresses) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintStaking(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *DVPair) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DVPair) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DVPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ValidatorAddress) > 0 {
		i -= len(m.ValidatorAddress)
		copy(dAtA[i:], m.ValidatorAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.DelegatorAddress) > 0 {
		i -= len(m.DelegatorAddress)
		copy(dAtA[i:], m.DelegatorAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DVPairs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DVPairs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DVPairs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Pairs) > 0 {
		for iNdEx := len(m.Pairs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Pairs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStaking(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *DVVTriplet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DVVTriplet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DVVTriplet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ValidatorDstAddress) > 0 {
		i -= len(m.ValidatorDstAddress)
		copy(dAtA[i:], m.ValidatorDstAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorDstAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ValidatorSrcAddress) > 0 {
		i -= len(m.ValidatorSrcAddress)
		copy(dAtA[i:], m.ValidatorSrcAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorSrcAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.DelegatorAddress) > 0 {
		i -= len(m.DelegatorAddress)
		copy(dAtA[i:], m.DelegatorAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DVVTriplets) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DVVTriplets) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DVVTriplets) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Triplets) > 0 {
		for iNdEx := len(m.Triplets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Triplets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStaking(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Delegation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Delegation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Delegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Shares.Size()
		i -= size
		if _, err := m.Shares.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.ValidatorAddress) > 0 {
		i -= len(m.ValidatorAddress)
		copy(dAtA[i:], m.ValidatorAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.DelegatorAddress) > 0 {
		i -= len(m.DelegatorAddress)
		copy(dAtA[i:], m.DelegatorAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UnbondingDelegation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnbondingDelegation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnbondingDelegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStaking(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.ValidatorAddress) > 0 {
		i -= len(m.ValidatorAddress)
		copy(dAtA[i:], m.ValidatorAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.DelegatorAddress) > 0 {
		i -= len(m.DelegatorAddress)
		copy(dAtA[i:], m.DelegatorAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UnbondingDelegationEntry) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnbondingDelegationEntry) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnbondingDelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Balance.Size()
		i -= size
		if _, err := m.Balance.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.InitialBalance.Size()
		i -= size
		if _, err := m.InitialBalance.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):])
	if err8 != nil {
		return 0, err8
	}
	i -= n8
	i = encodeVarintStaking(dAtA, i, uint64(n8))
	i--
	dAtA[i] = 0x12
	if m.CreationHeight != 0 {
		i = encodeVarintStaking(dAtA, i, uint64(m.CreationHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RedelegationEntry) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RedelegationEntry) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RedelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.SharesDst.Size()
		i -= size
		if _, err := m.SharesDst.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.InitialBalance.Size()
		i -= size
		if _, err := m.InitialBalance.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):])
	if err9 != nil {
		return 0, err9
	}
	i -= n9
	i = encodeVarintStaking(dAtA, i, uint64(n9))
	i--
	dAtA[i] = 0x12
	if m.CreationHeight != 0 {
		i = encodeVarintStaking(dAtA, i, uint64(m.CreationHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Redelegation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Redelegation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Redelegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStaking(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.ValidatorDstAddress) > 0 {
		i -= len(m.ValidatorDstAddress)
		copy(dAtA[i:], m.ValidatorDstAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorDstAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ValidatorSrcAddress) > 0 {
		i -= len(m.ValidatorSrcAddress)
		copy(dAtA[i:], m.ValidatorSrcAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorSrcAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.DelegatorAddress) > 0 {
		i -= len(m.DelegatorAddress)
		copy(dAtA[i:], m.DelegatorAddress)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Params) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Params) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.MinCommissionRate.Size()
		i -= size
		if _, err := m.MinCommissionRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if len(m.BondDenom) > 0 {
		i -= len(m.BondDenom)
		copy(dAtA[i:], m.BondDenom)
		i = encodeVarintStaking(dAtA, i, uint64(len(m.BondDenom)))
		i--
		dAtA[i] = 0x2a
	}
	if m.HistoricalEntries != 0 {
		i = encodeVarintStaking(dAtA, i, uint64(m.HistoricalEntries))
		i--
		dAtA[i] = 0x20
	}
	if m.MaxEntries != 0 {
		i = encodeVarintStaking(dAtA, i, uint64(m.MaxEntries))
		i--
		dAtA[i] = 0x18
	}
	if m.MaxValidators != 0 {
		i = encodeVarintStaking(dAtA, i, uint64(m.MaxValidators))
		i--
		dAtA[i] = 0x10
	}
	n10, err10 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime):])
	if err10 != nil {
		return 0, err10
	}
	i -= n10
	i = encodeVarintStaking(dAtA, i, uint64(n10))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *DelegationResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DelegationResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DelegationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Balance.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Delegation.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *RedelegationEntryResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RedelegationEntryResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RedelegationEntryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Balance.Size()
		i -= size
		if _, err := m.Balance.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.RedelegationEntry.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *RedelegationResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RedelegationResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RedelegationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStaking(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.Redelegation.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Pool) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Pool) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.BondedTokens.Size()
		i -= size
		if _, err := m.BondedTokens.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.NotBondedTokens.Size()
		i -= size
		if _, err := m.NotBondedTokens.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintStaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintStaking(dAtA []byte, offset int, v uint64) int {
	offset -= sovStaking(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *HistoricalInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Header.Size()
	n += 1 + l + sovStaking(uint64(l))
	if len(m.Valset) > 0 {
		for _, e := range m.Valset {
			l = e.Size()
			n += 1 + l + sovStaking(uint64(l))
		}
	}
	return n
}

func (m *CommissionRates) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Rate.Size()
	n += 1 + l + sovStaking(uint64(l))
	l = m.MaxRate.Size()
	n += 1 + l + sovStaking(uint64(l))
	l = m.MaxChangeRate.Size()
	n += 1 + l + sovStaking(uint64(l))
	return n
}

func (m *Commission) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.CommissionRates.Size()
	n += 1 + l + sovStaking(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime)
	n += 1 + l + sovStaking(uint64(l))
	return n
}

func (m *Description) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Moniker)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = len(m.Website)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = len(m.SecurityContact)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = len(m.Details)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	return n
}

func (m *Validator) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OperatorAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	if m.ConsensusPubkey != nil {
		l = m.ConsensusPubkey.Size()
		n += 1 + l + sovStaking(uint64(l))
	}
	if m.Jailed {
		n += 2
	}
	if m.Status != 0 {
		n += 1 + sovStaking(uint64(m.Status))
	}
	l = m.Tokens.Size()
	n += 1 + l + sovStaking(uint64(l))
	l = m.DelegatorShares.Size()
	n += 1 + l + sovStaking(uint64(l))
	l = m.Description.Size()
	n += 1 + l + sovStaking(uint64(l))
	if m.UnbondingHeight != 0 {
		n += 1 + sovStaking(uint64(m.UnbondingHeight))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime)
	n += 1 + l + sovStaking(uint64(l))
	l = m.Commission.Size()
	n += 1 + l + sovStaking(uint64(l))
	l = m.MinSelfDelegation.Size()
	n += 1 + l + sovStaking(uint64(l))
	return n
}

func (m *ValAddresses) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovStaking(uint64(l))
		}
	}
	return n
}

func (m *DVPair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DelegatorAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	return n
}

func (m *DVPairs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Pairs) > 0 {
		for _, e := range m.Pairs {
			l = e.Size()
			n += 1 + l + sovStaking(uint64(l))
		}
	}
	return n
}

func (m *DVVTriplet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DelegatorAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = len(m.ValidatorSrcAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = len(m.ValidatorDstAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	return n
}

func (m *DVVTriplets) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Triplets) > 0 {
		for _, e := range m.Triplets {
			l = e.Size()
			n += 1 + l + sovStaking(uint64(l))
		}
	}
	return n
}

func (m *Delegation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DelegatorAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = m.Shares.Size()
	n += 1 + l + sovStaking(uint64(l))
	return n
}

func (m *UnbondingDelegation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DelegatorAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovStaking(uint64(l))
		}
	}
	return n
}

func (m *UnbondingDelegationEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreationHeight != 0 {
		n += 1 + sovStaking(uint64(m.CreationHeight))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime)
	n += 1 + l + sovStaking(uint64(l))
	l = m.InitialBalance.Size()
	n += 1 + l + sovStaking(uint64(l))
	l = m.Balance.Size()
	n += 1 + l + sovStaking(uint64(l))
	return n
}

func (m *RedelegationEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreationHeight != 0 {
		n += 1 + sovStaking(uint64(m.CreationHeight))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime)
	n += 1 + l + sovStaking(uint64(l))
	l = m.InitialBalance.Size()
	n += 1 + l + sovStaking(uint64(l))
	l = m.SharesDst.Size()
	n += 1 + l + sovStaking(uint64(l))
	return n
}

func (m *Redelegation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DelegatorAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = len(m.ValidatorSrcAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = len(m.ValidatorDstAddress)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovStaking(uint64(l))
		}
	}
	return n
}

func (m *Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime)
	n += 1 + l + sovStaking(uint64(l))
	if m.MaxValidators != 0 {
		n += 1 + sovStaking(uint64(m.MaxValidators))
	}
	if m.MaxEntries != 0 {
		n += 1 + sovStaking(uint64(m.MaxEntries))
	}
	if m.HistoricalEntries != 0 {
		n += 1 + sovStaking(uint64(m.HistoricalEntries))
	}
	l = len(m.BondDenom)
	if l > 0 {
		n += 1 + l + sovStaking(uint64(l))
	}
	l = m.MinCommissionRate.Size()
	n += 1 + l + sovStaking(uint64(l))
	return n
}

func (m *DelegationResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Delegation.Size()
	n += 1 + l + sovStaking(uint64(l))
	l = m.Balance.Size()
	n += 1 + l + sovStaking(uint64(l))
	return n
}

func (m *RedelegationEntryResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.RedelegationEntry.Size()
	n += 1 + l + sovStaking(uint64(l))
	l = m.Balance.Size()
	n += 1 + l + sovStaking(uint64(l))
	return n
}

func (m *RedelegationResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Redelegation.Size()
	n += 1 + l + sovStaking(uint64(l))
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovStaking(uint64(l))
		}
	}
	return n
}

func (m *Pool) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.NotBondedTokens.Size()
	n += 1 + l + sovStaking(uint64(l))
	l = m.BondedTokens.Size()
	n += 1 + l + sovStaking(uint64(l))
	return n
}

func sovStaking(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozStaking(x uint64) (n int) {
	return sovStaking(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *ValAddresses) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ValAddresses{`,
		`Addresses:` + fmt.Sprintf("%v", this.Addresses) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringStaking(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *HistoricalInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: HistoricalInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HistoricalInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Valset", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Valset = append(m.Valset, Validator{})
			if err := m.Valset[len(m.Valset)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CommissionRates) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: CommissionRates: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommissionRates: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rate", 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.Rate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRate", 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.MaxRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxChangeRate", 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.MaxChangeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Commission) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Commission: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Commission: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommissionRates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CommissionRates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdateTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Description) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Description: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Description: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Moniker", 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
			}
			m.Moniker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", 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
			}
			m.Identity = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Website", 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
			}
			m.Website = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecurityContact", 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
			}
			m.SecurityContact = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", 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
			}
			m.Details = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Validator) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Validator: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", 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
			}
			m.OperatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusPubkey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConsensusPubkey == nil {
				m.ConsensusPubkey = &types1.Any{}
			}
			if err := m.ConsensusPubkey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Jailed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Jailed = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= BondStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tokens", 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.Tokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorShares", 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.DelegatorShares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Description.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingHeight", wireType)
			}
			m.UnbondingHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnbondingHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Commission", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Commission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinSelfDelegation", 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.MinSelfDelegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValAddresses) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: ValAddresses: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValAddresses: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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
			}
			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DVPair) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: DVPair: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DVPair: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", 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
			}
			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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
			}
			m.ValidatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DVPairs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: DVPairs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DVPairs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pairs = append(m.Pairs, DVPair{})
			if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DVVTriplet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: DVVTriplet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DVVTriplet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", 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
			}
			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSrcAddress", 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
			}
			m.ValidatorSrcAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDstAddress", 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
			}
			m.ValidatorDstAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DVVTriplets) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: DVVTriplets: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DVVTriplets: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Triplets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Triplets = append(m.Triplets, DVVTriplet{})
			if err := m.Triplets[len(m.Triplets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Delegation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Delegation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Delegation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", 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
			}
			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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
			}
			m.ValidatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shares", 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.Shares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnbondingDelegation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: UnbondingDelegation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnbondingDelegation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", 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
			}
			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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
			}
			m.ValidatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entries = append(m.Entries, UnbondingDelegationEntry{})
			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnbondingDelegationEntry) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: UnbondingDelegationEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnbondingDelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType)
			}
			m.CreationHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreationHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", 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.InitialBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Balance", 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.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RedelegationEntry) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: RedelegationEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RedelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType)
			}
			m.CreationHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreationHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", 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.InitialBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SharesDst", 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.SharesDst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Redelegation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Redelegation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Redelegation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", 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
			}
			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSrcAddress", 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
			}
			m.ValidatorSrcAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDstAddress", 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
			}
			m.ValidatorDstAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entries = append(m.Entries, RedelegationEntry{})
			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Params) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxValidators", wireType)
			}
			m.MaxValidators = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxValidators |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxEntries", wireType)
			}
			m.MaxEntries = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxEntries |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HistoricalEntries", wireType)
			}
			m.HistoricalEntries = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HistoricalEntries |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondDenom", 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
			}
			m.BondDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinCommissionRate", 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.MinCommissionRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelegationResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: DelegationResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Delegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RedelegationEntryResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: RedelegationEntryResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RedelegationEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedelegationEntry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RedelegationEntry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Balance", 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.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RedelegationResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: RedelegationResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RedelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Redelegation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Redelegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entries = append(m.Entries, RedelegationEntryResponse{})
			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Pool) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Pool: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Pool: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotBondedTokens", 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.NotBondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondedTokens", 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.BondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipStaking(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowStaking
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowStaking
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthStaking
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupStaking
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthStaking
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthStaking        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowStaking          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupStaking = fmt.Errorf("proto: unexpected end of group")
)