pubsubcollect.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pubsubcollect.proto

package pb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_libp2p_go_libp2p_core_peer "github.com/libp2p/go-libp2p-core/peer"
	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

type Msg_MsgType int32

const (
	Msg_Unknown  Msg_MsgType = 0
	Msg_Request  Msg_MsgType = 1
	Msg_Response Msg_MsgType = 2
	Msg_Hit      Msg_MsgType = 3
)

var Msg_MsgType_name = map[int32]string{
	0: "Unknown",
	1: "Request",
	2: "Response",
	3: "Hit",
}

var Msg_MsgType_value = map[string]int32{
	"Unknown":  0,
	"Request":  1,
	"Response": 2,
	"Hit":      3,
}

func (x Msg_MsgType) String() string {
	return proto.EnumName(Msg_MsgType_name, int32(x))
}

func (Msg_MsgType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8de5b98ea40541c9, []int{7, 0}
}

// Request is the structure transmit in overlay network, to perform a broadcast query.
type Request struct {
	// control is the routing messages.
	Control RequestControl `protobuf:"bytes,1,opt,name=control,proto3" json:"control"`
	Payload []byte         `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
}

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

var xxx_messageInfo_Request proto.InternalMessageInfo

type RequestControl struct {
	// requester is the peerid of the origin node
	Requester github_com_libp2p_go_libp2p_core_peer.ID `protobuf:"bytes,1,opt,name=requester,proto3,casttype=github.com/libp2p/go-libp2p-core/peer.ID" json:"requester,omitempty"`
	// sender is the node who gives you this request
	Sender github_com_libp2p_go_libp2p_core_peer.ID `protobuf:"bytes,2,opt,name=sender,proto3,casttype=github.com/libp2p/go-libp2p-core/peer.ID" json:"sender,omitempty"`
	// seqno is the sequence number helps to generate request id
	Seqno uint64 `protobuf:"varint,3,opt,name=seqno,proto3" json:"seqno,omitempty"`
	Hops  uint32 `protobuf:"varint,4,opt,name=hops,proto3" json:"hops,omitempty"`
	Topic string `protobuf:"bytes,5,opt,name=topic,proto3" json:"topic,omitempty"`
}

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

var xxx_messageInfo_RequestControl proto.InternalMessageInfo

type Intermediate struct {
	// hit decides whether send back to the root node
	// if hit is true, means that the current node has the wanted answer.
	Hit bool `protobuf:"varint,1,opt,name=hit,proto3" json:"hit,omitempty"`
	// response payload, which will be assembled into a response
	// be aware that THIS IS NOT response.marshal() result
	Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	// Error Message
	Error *Error `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_Intermediate proto.InternalMessageInfo

type Error struct {
	Code    uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}

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

var xxx_messageInfo_Error proto.InternalMessageInfo

// Response is the structure transmit in overlay network, to answer a broadcast query.
type Response struct {
	// control is the routing messages.
	Control ResponseControl `protobuf:"bytes,1,opt,name=control,proto3" json:"control"`
	Payload []byte          `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	// Error Message
	Error *Error `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_Response proto.InternalMessageInfo

type ResponseControl struct {
	// response related request id.
	RequestId RequestID `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3,casttype=RequestID" json:"request_id,omitempty"`
	// requester is the node who send the request
	Requester github_com_libp2p_go_libp2p_core_peer.ID `protobuf:"bytes,2,opt,name=requester,proto3,casttype=github.com/libp2p/go-libp2p-core/peer.ID" json:"requester,omitempty"`
	// responser is the node who generate the current response
	Responser github_com_libp2p_go_libp2p_core_peer.ID `protobuf:"bytes,3,opt,name=responser,proto3,casttype=github.com/libp2p/go-libp2p-core/peer.ID" json:"responser,omitempty"`
	// sender is the node who send you this response
	Sender github_com_libp2p_go_libp2p_core_peer.ID `protobuf:"bytes,4,opt,name=sender,proto3,casttype=github.com/libp2p/go-libp2p-core/peer.ID" json:"sender,omitempty"`
	Topic  string                                   `protobuf:"bytes,5,opt,name=topic,proto3" json:"topic,omitempty"`
}

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

var xxx_messageInfo_ResponseControl proto.InternalMessageInfo

type Responses struct {
	Responses []*Responses `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
}

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

var xxx_messageInfo_Responses proto.InternalMessageInfo

type Msg struct {
	Type     Msg_MsgType `protobuf:"varint,1,opt,name=type,proto3,enum=pb.Msg_MsgType" json:"type,omitempty"`
	Request  *Request    `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	Response *Response   `protobuf:"bytes,3,opt,name=response,proto3" json:"response,omitempty"`
}

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

var xxx_messageInfo_Msg proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("pb.Msg_MsgType", Msg_MsgType_name, Msg_MsgType_value)
	proto.RegisterType((*Request)(nil), "pb.Request")
	proto.RegisterType((*RequestControl)(nil), "pb.RequestControl")
	proto.RegisterType((*Intermediate)(nil), "pb.Intermediate")
	proto.RegisterType((*Error)(nil), "pb.Error")
	proto.RegisterType((*Response)(nil), "pb.Response")
	proto.RegisterType((*ResponseControl)(nil), "pb.ResponseControl")
	proto.RegisterType((*Responses)(nil), "pb.Responses")
	proto.RegisterType((*Msg)(nil), "pb.Msg")
}

func init() { proto.RegisterFile("pubsubcollect.proto", fileDescriptor_8de5b98ea40541c9) }

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

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

func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintPubsubcollect(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.Control.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintPubsubcollect(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *RequestControl) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Topic) > 0 {
		i -= len(m.Topic)
		copy(dAtA[i:], m.Topic)
		i = encodeVarintPubsubcollect(dAtA, i, uint64(len(m.Topic)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Hops != 0 {
		i = encodeVarintPubsubcollect(dAtA, i, uint64(m.Hops))
		i--
		dAtA[i] = 0x20
	}
	if m.Seqno != 0 {
		i = encodeVarintPubsubcollect(dAtA, i, uint64(m.Seqno))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintPubsubcollect(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Requester) > 0 {
		i -= len(m.Requester)
		copy(dAtA[i:], m.Requester)
		i = encodeVarintPubsubcollect(dAtA, i, uint64(len(m.Requester)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Intermediate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintPubsubcollect(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintPubsubcollect(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x12
	}
	if m.Hit {
		i--
		if m.Hit {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintPubsubcollect(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintPubsubcollect(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.Control.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintPubsubcollect(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *ResponseControl) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Topic) > 0 {
		i -= len(m.Topic)
		copy(dAtA[i:], m.Topic)
		i = encodeVarintPubsubcollect(dAtA, i, uint64(len(m.Topic)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintPubsubcollect(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Responser) > 0 {
		i -= len(m.Responser)
		copy(dAtA[i:], m.Responser)
		i = encodeVarintPubsubcollect(dAtA, i, uint64(len(m.Responser)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Requester) > 0 {
		i -= len(m.Requester)
		copy(dAtA[i:], m.Requester)
		i = encodeVarintPubsubcollect(dAtA, i, uint64(len(m.Requester)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RequestId) > 0 {
		i -= len(m.RequestId)
		copy(dAtA[i:], m.RequestId)
		i = encodeVarintPubsubcollect(dAtA, i, uint64(len(m.RequestId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *Msg) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Response != nil {
		{
			size, err := m.Response.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintPubsubcollect(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Request != nil {
		{
			size, err := m.Request.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintPubsubcollect(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintPubsubcollect(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintPubsubcollect(dAtA []byte, offset int, v uint64) int {
	offset -= sovPubsubcollect(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Control.Size()
	n += 1 + l + sovPubsubcollect(uint64(l))
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	return n
}

func (m *RequestControl) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Requester)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	if m.Seqno != 0 {
		n += 1 + sovPubsubcollect(uint64(m.Seqno))
	}
	if m.Hops != 0 {
		n += 1 + sovPubsubcollect(uint64(m.Hops))
	}
	l = len(m.Topic)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	return n
}

func (m *Intermediate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Hit {
		n += 2
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	return n
}

func (m *Error) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovPubsubcollect(uint64(m.Code))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	return n
}

func (m *Response) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Control.Size()
	n += 1 + l + sovPubsubcollect(uint64(l))
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	return n
}

func (m *ResponseControl) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RequestId)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	l = len(m.Requester)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	l = len(m.Responser)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	l = len(m.Topic)
	if l > 0 {
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	return n
}

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

func (m *Msg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovPubsubcollect(uint64(m.Type))
	}
	if m.Request != nil {
		l = m.Request.Size()
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	if m.Response != nil {
		l = m.Response.Size()
		n += 1 + l + sovPubsubcollect(uint64(l))
	}
	return n
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RequestControl) 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 ErrIntOverflowPubsubcollect
			}
			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: RequestControl: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RequestControl: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Requester", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				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 ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Requester = github_com_libp2p_go_libp2p_core_peer.ID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				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 ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = github_com_libp2p_go_libp2p_core_peer.ID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seqno", wireType)
			}
			m.Seqno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Seqno |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hops", wireType)
			}
			m.Hops = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Hops |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				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 ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Topic = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPubsubcollect(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Intermediate) 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 ErrIntOverflowPubsubcollect
			}
			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: Intermediate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Intermediate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hit", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Hit = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPubsubcollect(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Error) 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 ErrIntOverflowPubsubcollect
			}
			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: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				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 ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPubsubcollect(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResponseControl) 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 ErrIntOverflowPubsubcollect
			}
			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: ResponseControl: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResponseControl: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				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 ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequestId = RequestID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Requester", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				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 ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Requester = github_com_libp2p_go_libp2p_core_peer.ID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Responser", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				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 ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Responser = github_com_libp2p_go_libp2p_core_peer.ID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				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 ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = github_com_libp2p_go_libp2p_core_peer.ID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				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 ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Topic = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPubsubcollect(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Msg) 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 ErrIntOverflowPubsubcollect
			}
			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: Msg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Msg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Msg_MsgType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Request == nil {
				m.Request = &Request{}
			}
			if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Response", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPubsubcollect
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Response == nil {
				m.Response = &Response{}
			}
			if err := m.Response.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPubsubcollect(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPubsubcollect
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthPubsubcollect        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowPubsubcollect          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupPubsubcollect = fmt.Errorf("proto: unexpected end of group")
)