// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: tendermint/propagation/types.proto

package propagation

import (
	fmt "fmt"
	crypto "github.com/cometbft/cometbft/proto/tendermint/crypto"
	bits "github.com/cometbft/cometbft/proto/tendermint/libs/bits"
	types "github.com/cometbft/cometbft/proto/tendermint/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

// 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

// TxMetaData contains all information needed to commit to a transaction. Start
// and end are used to insert the transaction into the protobuf encoded version
// of the block.
type TxMetaData struct {
	Hash  []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Start uint32 `protobuf:"varint,2,opt,name=start,proto3" json:"start,omitempty"`
	End   uint32 `protobuf:"varint,3,opt,name=end,proto3" json:"end,omitempty"`
}

func (m *TxMetaData) Reset()         { *m = TxMetaData{} }
func (m *TxMetaData) String() string { return proto.CompactTextString(m) }
func (*TxMetaData) ProtoMessage()    {}
func (*TxMetaData) Descriptor() ([]byte, []int) {
	return fileDescriptor_95872042e9494569, []int{0}
}
func (m *TxMetaData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TxMetaData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TxMetaData.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 *TxMetaData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TxMetaData.Merge(m, src)
}
func (m *TxMetaData) XXX_Size() int {
	return m.Size()
}
func (m *TxMetaData) XXX_DiscardUnknown() {
	xxx_messageInfo_TxMetaData.DiscardUnknown(m)
}

var xxx_messageInfo_TxMetaData proto.InternalMessageInfo

func (m *TxMetaData) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *TxMetaData) GetStart() uint32 {
	if m != nil {
		return m.Start
	}
	return 0
}

func (m *TxMetaData) GetEnd() uint32 {
	if m != nil {
		return m.End
	}
	return 0
}

// CompactBlock commits to the transaction included in a proposal. It enalbes
// clients to reuse already downloaded blobs instead of gossiping them all again
// during the block propagation.
type CompactBlock struct {
	BpHash      []byte          `protobuf:"bytes,1,opt,name=bp_hash,json=bpHash,proto3" json:"bp_hash,omitempty"`
	Blobs       []*TxMetaData   `protobuf:"bytes,2,rep,name=blobs,proto3" json:"blobs,omitempty"`
	Signature   []byte          `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	Proposal    *types.Proposal `protobuf:"bytes,4,opt,name=proposal,proto3" json:"proposal,omitempty"`
	LastLength  uint32          `protobuf:"varint,5,opt,name=last_length,json=lastLength,proto3" json:"last_length,omitempty"`
	PartsHashes [][]byte        `protobuf:"bytes,6,rep,name=parts_hashes,json=partsHashes,proto3" json:"parts_hashes,omitempty"`
}

func (m *CompactBlock) Reset()         { *m = CompactBlock{} }
func (m *CompactBlock) String() string { return proto.CompactTextString(m) }
func (*CompactBlock) ProtoMessage()    {}
func (*CompactBlock) Descriptor() ([]byte, []int) {
	return fileDescriptor_95872042e9494569, []int{1}
}
func (m *CompactBlock) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CompactBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CompactBlock.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 *CompactBlock) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompactBlock.Merge(m, src)
}
func (m *CompactBlock) XXX_Size() int {
	return m.Size()
}
func (m *CompactBlock) XXX_DiscardUnknown() {
	xxx_messageInfo_CompactBlock.DiscardUnknown(m)
}

var xxx_messageInfo_CompactBlock proto.InternalMessageInfo

func (m *CompactBlock) GetBpHash() []byte {
	if m != nil {
		return m.BpHash
	}
	return nil
}

func (m *CompactBlock) GetBlobs() []*TxMetaData {
	if m != nil {
		return m.Blobs
	}
	return nil
}

func (m *CompactBlock) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *CompactBlock) GetProposal() *types.Proposal {
	if m != nil {
		return m.Proposal
	}
	return nil
}

func (m *CompactBlock) GetLastLength() uint32 {
	if m != nil {
		return m.LastLength
	}
	return 0
}

func (m *CompactBlock) GetPartsHashes() [][]byte {
	if m != nil {
		return m.PartsHashes
	}
	return nil
}

// PartMetaData proves the inclusion of a part to the block.
type PartMetaData struct {
	Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Hash  []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
}

func (m *PartMetaData) Reset()         { *m = PartMetaData{} }
func (m *PartMetaData) String() string { return proto.CompactTextString(m) }
func (*PartMetaData) ProtoMessage()    {}
func (*PartMetaData) Descriptor() ([]byte, []int) {
	return fileDescriptor_95872042e9494569, []int{2}
}
func (m *PartMetaData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PartMetaData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PartMetaData.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 *PartMetaData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PartMetaData.Merge(m, src)
}
func (m *PartMetaData) XXX_Size() int {
	return m.Size()
}
func (m *PartMetaData) XXX_DiscardUnknown() {
	xxx_messageInfo_PartMetaData.DiscardUnknown(m)
}

var xxx_messageInfo_PartMetaData proto.InternalMessageInfo

func (m *PartMetaData) GetIndex() uint32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *PartMetaData) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

// HaveParts is a message sent by a peer to inform that it has or will receive a
// part of a block.
type HaveParts struct {
	Height int64           `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	Round  int32           `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
	Parts  []*PartMetaData `protobuf:"bytes,3,rep,name=parts,proto3" json:"parts,omitempty"`
}

func (m *HaveParts) Reset()         { *m = HaveParts{} }
func (m *HaveParts) String() string { return proto.CompactTextString(m) }
func (*HaveParts) ProtoMessage()    {}
func (*HaveParts) Descriptor() ([]byte, []int) {
	return fileDescriptor_95872042e9494569, []int{3}
}
func (m *HaveParts) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HaveParts) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HaveParts.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 *HaveParts) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HaveParts.Merge(m, src)
}
func (m *HaveParts) XXX_Size() int {
	return m.Size()
}
func (m *HaveParts) XXX_DiscardUnknown() {
	xxx_messageInfo_HaveParts.DiscardUnknown(m)
}

var xxx_messageInfo_HaveParts proto.InternalMessageInfo

func (m *HaveParts) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *HaveParts) GetRound() int32 {
	if m != nil {
		return m.Round
	}
	return 0
}

func (m *HaveParts) GetParts() []*PartMetaData {
	if m != nil {
		return m.Parts
	}
	return nil
}

// WantParts is a wire message sent by peers to indicate that they wish to
// download a specific portion of the block.
type WantParts struct {
	Parts             bits.BitArray `protobuf:"bytes,1,opt,name=parts,proto3" json:"parts"`
	Height            int64         `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	Round             int32         `protobuf:"varint,3,opt,name=round,proto3" json:"round,omitempty"`
	Prove             bool          `protobuf:"varint,4,opt,name=prove,proto3" json:"prove,omitempty"`
	MissingPartsCount int32         `protobuf:"varint,5,opt,name=missing_parts_count,json=missingPartsCount,proto3" json:"missing_parts_count,omitempty"`
}

func (m *WantParts) Reset()         { *m = WantParts{} }
func (m *WantParts) String() string { return proto.CompactTextString(m) }
func (*WantParts) ProtoMessage()    {}
func (*WantParts) Descriptor() ([]byte, []int) {
	return fileDescriptor_95872042e9494569, []int{4}
}
func (m *WantParts) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WantParts) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WantParts.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 *WantParts) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WantParts.Merge(m, src)
}
func (m *WantParts) XXX_Size() int {
	return m.Size()
}
func (m *WantParts) XXX_DiscardUnknown() {
	xxx_messageInfo_WantParts.DiscardUnknown(m)
}

var xxx_messageInfo_WantParts proto.InternalMessageInfo

func (m *WantParts) GetParts() bits.BitArray {
	if m != nil {
		return m.Parts
	}
	return bits.BitArray{}
}

func (m *WantParts) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *WantParts) GetRound() int32 {
	if m != nil {
		return m.Round
	}
	return 0
}

func (m *WantParts) GetProve() bool {
	if m != nil {
		return m.Prove
	}
	return false
}

func (m *WantParts) GetMissingPartsCount() int32 {
	if m != nil {
		return m.MissingPartsCount
	}
	return 0
}

// RecoveryPart is a wire message for sending a portion of the block to a peer.
type RecoveryPart struct {
	Height int64        `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	Round  int32        `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
	Index  uint32       `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
	Data   []byte       `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
	Proof  crypto.Proof `protobuf:"bytes,5,opt,name=proof,proto3" json:"proof"`
}

func (m *RecoveryPart) Reset()         { *m = RecoveryPart{} }
func (m *RecoveryPart) String() string { return proto.CompactTextString(m) }
func (*RecoveryPart) ProtoMessage()    {}
func (*RecoveryPart) Descriptor() ([]byte, []int) {
	return fileDescriptor_95872042e9494569, []int{5}
}
func (m *RecoveryPart) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RecoveryPart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RecoveryPart.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 *RecoveryPart) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RecoveryPart.Merge(m, src)
}
func (m *RecoveryPart) XXX_Size() int {
	return m.Size()
}
func (m *RecoveryPart) XXX_DiscardUnknown() {
	xxx_messageInfo_RecoveryPart.DiscardUnknown(m)
}

var xxx_messageInfo_RecoveryPart proto.InternalMessageInfo

func (m *RecoveryPart) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *RecoveryPart) GetRound() int32 {
	if m != nil {
		return m.Round
	}
	return 0
}

func (m *RecoveryPart) GetIndex() uint32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *RecoveryPart) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *RecoveryPart) GetProof() crypto.Proof {
	if m != nil {
		return m.Proof
	}
	return crypto.Proof{}
}

type Message struct {
	// Types that are valid to be assigned to Sum:
	//	*Message_CompactBlock
	//	*Message_HaveParts
	//	*Message_WantParts
	//	*Message_RecoveryPart
	Sum isMessage_Sum `protobuf_oneof:"sum"`
}

func (m *Message) Reset()         { *m = Message{} }
func (m *Message) String() string { return proto.CompactTextString(m) }
func (*Message) ProtoMessage()    {}
func (*Message) Descriptor() ([]byte, []int) {
	return fileDescriptor_95872042e9494569, []int{6}
}
func (m *Message) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Message.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 *Message) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Message.Merge(m, src)
}
func (m *Message) XXX_Size() int {
	return m.Size()
}
func (m *Message) XXX_DiscardUnknown() {
	xxx_messageInfo_Message.DiscardUnknown(m)
}

var xxx_messageInfo_Message proto.InternalMessageInfo

type isMessage_Sum interface {
	isMessage_Sum()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Message_CompactBlock struct {
	CompactBlock *CompactBlock `protobuf:"bytes,1,opt,name=compact_block,json=compactBlock,proto3,oneof" json:"compact_block,omitempty"`
}
type Message_HaveParts struct {
	HaveParts *HaveParts `protobuf:"bytes,2,opt,name=have_parts,json=haveParts,proto3,oneof" json:"have_parts,omitempty"`
}
type Message_WantParts struct {
	WantParts *WantParts `protobuf:"bytes,3,opt,name=want_parts,json=wantParts,proto3,oneof" json:"want_parts,omitempty"`
}
type Message_RecoveryPart struct {
	RecoveryPart *RecoveryPart `protobuf:"bytes,4,opt,name=recovery_part,json=recoveryPart,proto3,oneof" json:"recovery_part,omitempty"`
}

func (*Message_CompactBlock) isMessage_Sum() {}
func (*Message_HaveParts) isMessage_Sum()    {}
func (*Message_WantParts) isMessage_Sum()    {}
func (*Message_RecoveryPart) isMessage_Sum() {}

func (m *Message) GetSum() isMessage_Sum {
	if m != nil {
		return m.Sum
	}
	return nil
}

func (m *Message) GetCompactBlock() *CompactBlock {
	if x, ok := m.GetSum().(*Message_CompactBlock); ok {
		return x.CompactBlock
	}
	return nil
}

func (m *Message) GetHaveParts() *HaveParts {
	if x, ok := m.GetSum().(*Message_HaveParts); ok {
		return x.HaveParts
	}
	return nil
}

func (m *Message) GetWantParts() *WantParts {
	if x, ok := m.GetSum().(*Message_WantParts); ok {
		return x.WantParts
	}
	return nil
}

func (m *Message) GetRecoveryPart() *RecoveryPart {
	if x, ok := m.GetSum().(*Message_RecoveryPart); ok {
		return x.RecoveryPart
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Message) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Message_CompactBlock)(nil),
		(*Message_HaveParts)(nil),
		(*Message_WantParts)(nil),
		(*Message_RecoveryPart)(nil),
	}
}

func init() {
	proto.RegisterType((*TxMetaData)(nil), "tendermint.propagation.TxMetaData")
	proto.RegisterType((*CompactBlock)(nil), "tendermint.propagation.CompactBlock")
	proto.RegisterType((*PartMetaData)(nil), "tendermint.propagation.PartMetaData")
	proto.RegisterType((*HaveParts)(nil), "tendermint.propagation.HaveParts")
	proto.RegisterType((*WantParts)(nil), "tendermint.propagation.WantParts")
	proto.RegisterType((*RecoveryPart)(nil), "tendermint.propagation.RecoveryPart")
	proto.RegisterType((*Message)(nil), "tendermint.propagation.Message")
}

func init() {
	proto.RegisterFile("tendermint/propagation/types.proto", fileDescriptor_95872042e9494569)
}

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

func (m *TxMetaData) 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 *TxMetaData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TxMetaData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.End != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.End))
		i--
		dAtA[i] = 0x18
	}
	if m.Start != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Start))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CompactBlock) 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 *CompactBlock) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CompactBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PartsHashes) > 0 {
		for iNdEx := len(m.PartsHashes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PartsHashes[iNdEx])
			copy(dAtA[i:], m.PartsHashes[iNdEx])
			i = encodeVarintTypes(dAtA, i, uint64(len(m.PartsHashes[iNdEx])))
			i--
			dAtA[i] = 0x32
		}
	}
	if m.LastLength != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.LastLength))
		i--
		dAtA[i] = 0x28
	}
	if m.Proposal != nil {
		{
			size, err := m.Proposal.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Blobs) > 0 {
		for iNdEx := len(m.Blobs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Blobs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.BpHash) > 0 {
		i -= len(m.BpHash)
		copy(dAtA[i:], m.BpHash)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.BpHash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PartMetaData) 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 *PartMetaData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PartMetaData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0x12
	}
	if m.Index != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *HaveParts) 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 *HaveParts) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HaveParts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Parts) > 0 {
		for iNdEx := len(m.Parts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Parts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Round != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Round))
		i--
		dAtA[i] = 0x10
	}
	if m.Height != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *WantParts) 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 *WantParts) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WantParts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MissingPartsCount != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.MissingPartsCount))
		i--
		dAtA[i] = 0x28
	}
	if m.Prove {
		i--
		if m.Prove {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Round != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Round))
		i--
		dAtA[i] = 0x18
	}
	if m.Height != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Parts.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *RecoveryPart) 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 *RecoveryPart) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RecoveryPart) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x22
	}
	if m.Index != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x18
	}
	if m.Round != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Round))
		i--
		dAtA[i] = 0x10
	}
	if m.Height != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Message) 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 *Message) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Message) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Sum != nil {
		{
			size := m.Sum.Size()
			i -= size
			if _, err := m.Sum.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Message_CompactBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CompactBlock != nil {
		{
			size, err := m.CompactBlock.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *Message_HaveParts) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Message_HaveParts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.HaveParts != nil {
		{
			size, err := m.HaveParts.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *Message_WantParts) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Message_WantParts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.WantParts != nil {
		{
			size, err := m.WantParts.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *Message_RecoveryPart) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Message_RecoveryPart) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RecoveryPart != nil {
		{
			size, err := m.RecoveryPart.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
	offset -= sovTypes(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *TxMetaData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Start != 0 {
		n += 1 + sovTypes(uint64(m.Start))
	}
	if m.End != 0 {
		n += 1 + sovTypes(uint64(m.End))
	}
	return n
}

func (m *CompactBlock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BpHash)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if len(m.Blobs) > 0 {
		for _, e := range m.Blobs {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Proposal != nil {
		l = m.Proposal.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.LastLength != 0 {
		n += 1 + sovTypes(uint64(m.LastLength))
	}
	if len(m.PartsHashes) > 0 {
		for _, b := range m.PartsHashes {
			l = len(b)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func (m *PartMetaData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovTypes(uint64(m.Index))
	}
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *HaveParts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovTypes(uint64(m.Height))
	}
	if m.Round != 0 {
		n += 1 + sovTypes(uint64(m.Round))
	}
	if len(m.Parts) > 0 {
		for _, e := range m.Parts {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func (m *WantParts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Parts.Size()
	n += 1 + l + sovTypes(uint64(l))
	if m.Height != 0 {
		n += 1 + sovTypes(uint64(m.Height))
	}
	if m.Round != 0 {
		n += 1 + sovTypes(uint64(m.Round))
	}
	if m.Prove {
		n += 2
	}
	if m.MissingPartsCount != 0 {
		n += 1 + sovTypes(uint64(m.MissingPartsCount))
	}
	return n
}

func (m *RecoveryPart) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovTypes(uint64(m.Height))
	}
	if m.Round != 0 {
		n += 1 + sovTypes(uint64(m.Round))
	}
	if m.Index != 0 {
		n += 1 + sovTypes(uint64(m.Index))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Proof.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *Message) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sum != nil {
		n += m.Sum.Size()
	}
	return n
}

func (m *Message_CompactBlock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CompactBlock != nil {
		l = m.CompactBlock.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *Message_HaveParts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HaveParts != nil {
		l = m.HaveParts.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *Message_WantParts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.WantParts != nil {
		l = m.WantParts.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *Message_RecoveryPart) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RecoveryPart != nil {
		l = m.RecoveryPart.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func sovTypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTypes(x uint64) (n int) {
	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TxMetaData) 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 ErrIntOverflowTypes
			}
			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: TxMetaData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxMetaData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
			if m.Hash == nil {
				m.Hash = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			m.Start = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Start |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
			}
			m.End = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.End |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CompactBlock) 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 ErrIntOverflowTypes
			}
			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: CompactBlock: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompactBlock: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BpHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BpHash = append(m.BpHash[:0], dAtA[iNdEx:postIndex]...)
			if m.BpHash == nil {
				m.BpHash = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Blobs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Blobs = append(m.Blobs, &TxMetaData{})
			if err := m.Blobs[len(m.Blobs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Proposal == nil {
				m.Proposal = &types.Proposal{}
			}
			if err := m.Proposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastLength", wireType)
			}
			m.LastLength = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastLength |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartsHashes", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PartsHashes = append(m.PartsHashes, make([]byte, postIndex-iNdEx))
			copy(m.PartsHashes[len(m.PartsHashes)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PartMetaData) 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 ErrIntOverflowTypes
			}
			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: PartMetaData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PartMetaData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
			if m.Hash == nil {
				m.Hash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HaveParts) 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 ErrIntOverflowTypes
			}
			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: HaveParts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HaveParts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType)
			}
			m.Round = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Round |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Parts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Parts = append(m.Parts, &PartMetaData{})
			if err := m.Parts[len(m.Parts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WantParts) 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 ErrIntOverflowTypes
			}
			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: WantParts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WantParts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Parts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Parts.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType)
			}
			m.Round = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Round |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prove", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Prove = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MissingPartsCount", wireType)
			}
			m.MissingPartsCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MissingPartsCount |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecoveryPart) 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 ErrIntOverflowTypes
			}
			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: RecoveryPart: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecoveryPart: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType)
			}
			m.Round = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Round |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Message) 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 ErrIntOverflowTypes
			}
			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: Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompactBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CompactBlock{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Sum = &Message_CompactBlock{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HaveParts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HaveParts{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Sum = &Message_HaveParts{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WantParts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WantParts{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Sum = &Message_WantParts{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecoveryPart", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RecoveryPart{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Sum = &Message_RecoveryPart{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTypes(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, ErrIntOverflowTypes
			}
			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, ErrIntOverflowTypes
				}
				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, ErrIntOverflowTypes
				}
				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, ErrInvalidLengthTypes
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTypes
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTypes
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
)
