staking.pb.go

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

package staking

import (
	bytes "bytes"
	compress_gzip "compress/gzip"
	fmt "fmt"
	_ "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"
	_ "github.com/golang/protobuf/ptypes/duration"
	_ "github.com/golang/protobuf/ptypes/timestamp"
	_ "github.com/regen-network/cosmos-proto"
	types "github.com/tendermint/tendermint/proto/tendermint/types"
	io "io"
	io_ioutil "io/ioutil"
	math "math"
	math_bits "math/bits"
	types1 "plugchain-sdk-go/codec/types"
	plugchain_sdk_go_types "plugchain-sdk-go/types"
	types2 "plugchain-sdk-go/types"
	reflect "reflect"
	strings "strings"
	time "time"
)

// 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          plugchain_sdk_go_types.Dec `protobuf:"bytes,1,opt,name=rate,proto3,customtype=github.com/oracleNetworkProtocol/plugchain-sdk-go/types.Dec" json:"rate"`
	MaxRate       plugchain_sdk_go_types.Dec `protobuf:"bytes,2,opt,name=max_rate,json=maxRate,proto3,customtype=github.com/oracleNetworkProtocol/plugchain-sdk-go/types.Dec" json:"max_rate" yaml:"max_rate"`
	MaxChangeRate plugchain_sdk_go_types.Dec `protobuf:"bytes,3,opt,name=max_change_rate,json=maxChangeRate,proto3,customtype=github.com/oracleNetworkProtocol/plugchain-sdk-go/types.Dec" json:"max_change_rate" yaml:"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 {
	CommissionRates `protobuf:"bytes,1,opt,name=commission_rates,json=commissionRates,proto3,embedded=commission_rates" json:"commission_rates"`
	UpdateTime      time.Time `protobuf:"bytes,2,opt,name=update_time,json=updateTime,proto3,stdtime" json:"update_time" yaml:"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         string `protobuf:"bytes,1,opt,name=moniker,proto3" json:"moniker,omitempty"`
	Identity        string `protobuf:"bytes,2,opt,name=identity,proto3" json:"identity,omitempty"`
	Website         string `protobuf:"bytes,3,opt,name=website,proto3" json:"website,omitempty"`
	SecurityContact string `protobuf:"bytes,4,opt,name=security_contact,json=securityContact,proto3" json:"security_contact,omitempty" yaml:"security_contact"`
	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 {
	OperatorAddress   string                                      `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty" yaml:"operator_address"`
	ConsensusPubkey   *types1.Any                                 `protobuf:"bytes,2,opt,name=consensus_pubkey,json=consensusPubkey,proto3" json:"consensus_pubkey,omitempty" yaml:"consensus_pubkey"`
	Jailed            bool                                        `protobuf:"varint,3,opt,name=jailed,proto3" json:"jailed,omitempty"`
	Status            BondStatus                                  `protobuf:"varint,4,opt,name=status,proto3,enum=cosmos.staking.v1beta1.BondStatus" json:"status,omitempty"`
	Tokens            plugchain_sdk_go_types.Int `protobuf:"bytes,5,opt,name=tokens,proto3,customtype=github.com/oracleNetworkProtocol/plugchain-sdk-go/types.Int" json:"tokens"`
	DelegatorShares   plugchain_sdk_go_types.Dec `protobuf:"bytes,6,opt,name=delegator_shares,json=delegatorShares,proto3,customtype=github.com/oracleNetworkProtocol/plugchain-sdk-go/types.Dec" json:"delegator_shares" yaml:"delegator_shares"`
	Description       Description                                 `protobuf:"bytes,7,opt,name=description,proto3" json:"description"`
	UnbondingHeight   int64                                       `protobuf:"varint,8,opt,name=unbonding_height,json=unbondingHeight,proto3" json:"unbonding_height,omitempty" yaml:"unbonding_height"`
	UnbondingTime     time.Time                                   `protobuf:"bytes,9,opt,name=unbonding_time,json=unbondingTime,proto3,stdtime" json:"unbonding_time" yaml:"unbonding_time"`
	Commission        Commission                                  `protobuf:"bytes,10,opt,name=commission,proto3" json:"commission"`
	MinSelfDelegation plugchain_sdk_go_types.Int `protobuf:"bytes,11,opt,name=min_self_delegation,json=minSelfDelegation,proto3,customtype=github.com/oracleNetworkProtocol/plugchain-sdk-go/types.Int" json:"min_self_delegation" yaml:"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" yaml:"delegator_address"`
	ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
}

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" yaml:"delegator_address"`
	ValidatorSrcAddress string `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty" yaml:"validator_src_address"`
	ValidatorDstAddress string `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty" yaml:"validator_dst_address"`
}

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 {
	DelegatorAddress string                                      `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
	ValidatorAddress string                                      `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
	Shares           plugchain_sdk_go_types.Dec `protobuf:"bytes,3,opt,name=shares,proto3,customtype=github.com/xiaka53/plugchain-sdk-go/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 {
	DelegatorAddress string                     `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
	ValidatorAddress string                     `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
	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 {
	CreationHeight int64                                       `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
	CompletionTime time.Time                                   `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
	InitialBalance plugchain_sdk_go_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/xiaka53/plugchain-sdk-go/types.Int" json:"initial_balance" yaml:"initial_balance"`
	Balance        plugchain_sdk_go_types.Int `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/xiaka53/plugchain-sdk-go/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 {
	CreationHeight int64                                       `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
	CompletionTime time.Time                                   `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
	InitialBalance plugchain_sdk_go_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/xiaka53/plugchain-sdk-go/types.Int" json:"initial_balance" yaml:"initial_balance"`
	SharesDst      plugchain_sdk_go_types.Dec `protobuf:"bytes,4,opt,name=shares_dst,json=sharesDst,proto3,customtype=github.com/xiaka53/plugchain-sdk-go/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 {
	DelegatorAddress    string              `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
	ValidatorSrcAddress string              `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty" yaml:"validator_src_address"`
	ValidatorDstAddress string              `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty" yaml:"validator_dst_address"`
	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 {
	UnbondingTime     time.Duration `protobuf:"bytes,1,opt,name=unbonding_time,json=unbondingTime,proto3,stdduration" json:"unbonding_time" yaml:"unbonding_time"`
	MaxValidators     uint32        `protobuf:"varint,2,opt,name=max_validators,json=maxValidators,proto3" json:"max_validators,omitempty" yaml:"max_validators"`
	MaxEntries        uint32        `protobuf:"varint,3,opt,name=max_entries,json=maxEntries,proto3" json:"max_entries,omitempty" yaml:"max_entries"`
	HistoricalEntries uint32        `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty" yaml:"historical_entries"`
	BondDenom         string        `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty" yaml:"bond_denom"`
}

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    types2.Coin `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() types2.Coin {
	if m != nil {
		return m.Balance
	}
	return types2.Coin{}
}

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