p2pnext.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: p2pnext.proto

package types

import (
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type MessageComm struct {
	// shared between all requests
	Version              string   `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	Timestamp            int64    `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Id                   string   `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
	Gossip               bool     `protobuf:"varint,4,opt,name=gossip,proto3" json:"gossip,omitempty"`
	NodeId               string   `protobuf:"bytes,5,opt,name=nodeId,proto3" json:"nodeId,omitempty"`
	NodePubKey           []byte   `protobuf:"bytes,6,opt,name=nodePubKey,proto3" json:"nodePubKey,omitempty"`
	Sign                 []byte   `protobuf:"bytes,7,opt,name=sign,proto3" json:"sign,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessageComm) Reset()         { *m = MessageComm{} }
func (m *MessageComm) String() string { return proto.CompactTextString(m) }
func (*MessageComm) ProtoMessage()    {}
func (*MessageComm) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{0}
}

func (m *MessageComm) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageComm.Unmarshal(m, b)
}
func (m *MessageComm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageComm.Marshal(b, m, deterministic)
}
func (m *MessageComm) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageComm.Merge(m, src)
}
func (m *MessageComm) XXX_Size() int {
	return xxx_messageInfo_MessageComm.Size(m)
}
func (m *MessageComm) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageComm.DiscardUnknown(m)
}

var xxx_messageInfo_MessageComm proto.InternalMessageInfo

func (m *MessageComm) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *MessageComm) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *MessageComm) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *MessageComm) GetGossip() bool {
	if m != nil {
		return m.Gossip
	}
	return false
}

func (m *MessageComm) GetNodeId() string {
	if m != nil {
		return m.NodeId
	}
	return ""
}

func (m *MessageComm) GetNodePubKey() []byte {
	if m != nil {
		return m.NodePubKey
	}
	return nil
}

func (m *MessageComm) GetSign() []byte {
	if m != nil {
		return m.Sign
	}
	return nil
}

type MessageUtil struct {
	Common *MessageComm `protobuf:"bytes,1,opt,name=common,proto3" json:"common,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*MessageUtil_PeerInfo
	//	*MessageUtil_Version
	//	*MessageUtil_VersionAck
	//	*MessageUtil_External
	//	*MessageUtil_Getblocks
	//	*MessageUtil_Invdatas
	Value                isMessageUtil_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *MessageUtil) Reset()         { *m = MessageUtil{} }
func (m *MessageUtil) String() string { return proto.CompactTextString(m) }
func (*MessageUtil) ProtoMessage()    {}
func (*MessageUtil) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{1}
}

func (m *MessageUtil) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageUtil.Unmarshal(m, b)
}
func (m *MessageUtil) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageUtil.Marshal(b, m, deterministic)
}
func (m *MessageUtil) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageUtil.Merge(m, src)
}
func (m *MessageUtil) XXX_Size() int {
	return xxx_messageInfo_MessageUtil.Size(m)
}
func (m *MessageUtil) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageUtil.DiscardUnknown(m)
}

var xxx_messageInfo_MessageUtil proto.InternalMessageInfo

func (m *MessageUtil) GetCommon() *MessageComm {
	if m != nil {
		return m.Common
	}
	return nil
}

type isMessageUtil_Value interface {
	isMessageUtil_Value()
}

type MessageUtil_PeerInfo struct {
	PeerInfo *P2PPeerInfo `protobuf:"bytes,2,opt,name=peerInfo,proto3,oneof"`
}

type MessageUtil_Version struct {
	Version *P2PVersion `protobuf:"bytes,3,opt,name=version,proto3,oneof"`
}

type MessageUtil_VersionAck struct {
	VersionAck *P2PVerAck `protobuf:"bytes,4,opt,name=versionAck,proto3,oneof"`
}

type MessageUtil_External struct {
	External *P2PExternalInfo `protobuf:"bytes,5,opt,name=external,proto3,oneof"`
}

type MessageUtil_Getblocks struct {
	Getblocks *P2PGetBlocks `protobuf:"bytes,6,opt,name=getblocks,proto3,oneof"`
}

type MessageUtil_Invdatas struct {
	Invdatas *InvDatas `protobuf:"bytes,7,opt,name=invdatas,proto3,oneof"`
}

func (*MessageUtil_PeerInfo) isMessageUtil_Value() {}

func (*MessageUtil_Version) isMessageUtil_Value() {}

func (*MessageUtil_VersionAck) isMessageUtil_Value() {}

func (*MessageUtil_External) isMessageUtil_Value() {}

func (*MessageUtil_Getblocks) isMessageUtil_Value() {}

func (*MessageUtil_Invdatas) isMessageUtil_Value() {}

func (m *MessageUtil) GetValue() isMessageUtil_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *MessageUtil) GetPeerInfo() *P2PPeerInfo {
	if x, ok := m.GetValue().(*MessageUtil_PeerInfo); ok {
		return x.PeerInfo
	}
	return nil
}

func (m *MessageUtil) GetVersion() *P2PVersion {
	if x, ok := m.GetValue().(*MessageUtil_Version); ok {
		return x.Version
	}
	return nil
}

func (m *MessageUtil) GetVersionAck() *P2PVerAck {
	if x, ok := m.GetValue().(*MessageUtil_VersionAck); ok {
		return x.VersionAck
	}
	return nil
}

func (m *MessageUtil) GetExternal() *P2PExternalInfo {
	if x, ok := m.GetValue().(*MessageUtil_External); ok {
		return x.External
	}
	return nil
}

func (m *MessageUtil) GetGetblocks() *P2PGetBlocks {
	if x, ok := m.GetValue().(*MessageUtil_Getblocks); ok {
		return x.Getblocks
	}
	return nil
}

func (m *MessageUtil) GetInvdatas() *InvDatas {
	if x, ok := m.GetValue().(*MessageUtil_Invdatas); ok {
		return x.Invdatas
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*MessageUtil) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*MessageUtil_PeerInfo)(nil),
		(*MessageUtil_Version)(nil),
		(*MessageUtil_VersionAck)(nil),
		(*MessageUtil_External)(nil),
		(*MessageUtil_Getblocks)(nil),
		(*MessageUtil_Invdatas)(nil),
	}
}

//*
// 请求获取远程节点的节点信息
type MessagePeerInfoReq struct {
	/// p2p版本
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessagePeerInfoReq) Reset()         { *m = MessagePeerInfoReq{} }
func (m *MessagePeerInfoReq) String() string { return proto.CompactTextString(m) }
func (*MessagePeerInfoReq) ProtoMessage()    {}
func (*MessagePeerInfoReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{2}
}

func (m *MessagePeerInfoReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagePeerInfoReq.Unmarshal(m, b)
}
func (m *MessagePeerInfoReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagePeerInfoReq.Marshal(b, m, deterministic)
}
func (m *MessagePeerInfoReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagePeerInfoReq.Merge(m, src)
}
func (m *MessagePeerInfoReq) XXX_Size() int {
	return xxx_messageInfo_MessagePeerInfoReq.Size(m)
}
func (m *MessagePeerInfoReq) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagePeerInfoReq.DiscardUnknown(m)
}

var xxx_messageInfo_MessagePeerInfoReq proto.InternalMessageInfo

func (m *MessagePeerInfoReq) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

type MessagePeerInfoResp struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PPeerInfo `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessagePeerInfoResp) Reset()         { *m = MessagePeerInfoResp{} }
func (m *MessagePeerInfoResp) String() string { return proto.CompactTextString(m) }
func (*MessagePeerInfoResp) ProtoMessage()    {}
func (*MessagePeerInfoResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{3}
}

func (m *MessagePeerInfoResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagePeerInfoResp.Unmarshal(m, b)
}
func (m *MessagePeerInfoResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagePeerInfoResp.Marshal(b, m, deterministic)
}
func (m *MessagePeerInfoResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagePeerInfoResp.Merge(m, src)
}
func (m *MessagePeerInfoResp) XXX_Size() int {
	return xxx_messageInfo_MessagePeerInfoResp.Size(m)
}
func (m *MessagePeerInfoResp) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagePeerInfoResp.DiscardUnknown(m)
}

var xxx_messageInfo_MessagePeerInfoResp proto.InternalMessageInfo

func (m *MessagePeerInfoResp) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessagePeerInfoResp) GetMessage() *P2PPeerInfo {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageP2PVersionReq struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PVersion  `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessageP2PVersionReq) Reset()         { *m = MessageP2PVersionReq{} }
func (m *MessageP2PVersionReq) String() string { return proto.CompactTextString(m) }
func (*MessageP2PVersionReq) ProtoMessage()    {}
func (*MessageP2PVersionReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{4}
}

func (m *MessageP2PVersionReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageP2PVersionReq.Unmarshal(m, b)
}
func (m *MessageP2PVersionReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageP2PVersionReq.Marshal(b, m, deterministic)
}
func (m *MessageP2PVersionReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageP2PVersionReq.Merge(m, src)
}
func (m *MessageP2PVersionReq) XXX_Size() int {
	return xxx_messageInfo_MessageP2PVersionReq.Size(m)
}
func (m *MessageP2PVersionReq) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageP2PVersionReq.DiscardUnknown(m)
}

var xxx_messageInfo_MessageP2PVersionReq proto.InternalMessageInfo

func (m *MessageP2PVersionReq) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageP2PVersionReq) GetMessage() *P2PVersion {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageP2PVersionResp struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PVersion  `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessageP2PVersionResp) Reset()         { *m = MessageP2PVersionResp{} }
func (m *MessageP2PVersionResp) String() string { return proto.CompactTextString(m) }
func (*MessageP2PVersionResp) ProtoMessage()    {}
func (*MessageP2PVersionResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{5}
}

func (m *MessageP2PVersionResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageP2PVersionResp.Unmarshal(m, b)
}
func (m *MessageP2PVersionResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageP2PVersionResp.Marshal(b, m, deterministic)
}
func (m *MessageP2PVersionResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageP2PVersionResp.Merge(m, src)
}
func (m *MessageP2PVersionResp) XXX_Size() int {
	return xxx_messageInfo_MessageP2PVersionResp.Size(m)
}
func (m *MessageP2PVersionResp) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageP2PVersionResp.DiscardUnknown(m)
}

var xxx_messageInfo_MessageP2PVersionResp proto.InternalMessageInfo

func (m *MessageP2PVersionResp) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageP2PVersionResp) GetMessage() *P2PVersion {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessagePingReq struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PPing     `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessagePingReq) Reset()         { *m = MessagePingReq{} }
func (m *MessagePingReq) String() string { return proto.CompactTextString(m) }
func (*MessagePingReq) ProtoMessage()    {}
func (*MessagePingReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{6}
}

func (m *MessagePingReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagePingReq.Unmarshal(m, b)
}
func (m *MessagePingReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagePingReq.Marshal(b, m, deterministic)
}
func (m *MessagePingReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagePingReq.Merge(m, src)
}
func (m *MessagePingReq) XXX_Size() int {
	return xxx_messageInfo_MessagePingReq.Size(m)
}
func (m *MessagePingReq) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagePingReq.DiscardUnknown(m)
}

var xxx_messageInfo_MessagePingReq proto.InternalMessageInfo

func (m *MessagePingReq) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessagePingReq) GetMessage() *P2PPing {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessagePingResp struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PPong     `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessagePingResp) Reset()         { *m = MessagePingResp{} }
func (m *MessagePingResp) String() string { return proto.CompactTextString(m) }
func (*MessagePingResp) ProtoMessage()    {}
func (*MessagePingResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{7}
}

func (m *MessagePingResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagePingResp.Unmarshal(m, b)
}
func (m *MessagePingResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagePingResp.Marshal(b, m, deterministic)
}
func (m *MessagePingResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagePingResp.Merge(m, src)
}
func (m *MessagePingResp) XXX_Size() int {
	return xxx_messageInfo_MessagePingResp.Size(m)
}
func (m *MessagePingResp) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagePingResp.DiscardUnknown(m)
}

var xxx_messageInfo_MessagePingResp proto.InternalMessageInfo

func (m *MessagePingResp) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessagePingResp) GetMessage() *P2PPong {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageAddrReq struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PGetAddr  `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessageAddrReq) Reset()         { *m = MessageAddrReq{} }
func (m *MessageAddrReq) String() string { return proto.CompactTextString(m) }
func (*MessageAddrReq) ProtoMessage()    {}
func (*MessageAddrReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{8}
}

func (m *MessageAddrReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageAddrReq.Unmarshal(m, b)
}
func (m *MessageAddrReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageAddrReq.Marshal(b, m, deterministic)
}
func (m *MessageAddrReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageAddrReq.Merge(m, src)
}
func (m *MessageAddrReq) XXX_Size() int {
	return xxx_messageInfo_MessageAddrReq.Size(m)
}
func (m *MessageAddrReq) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageAddrReq.DiscardUnknown(m)
}

var xxx_messageInfo_MessageAddrReq proto.InternalMessageInfo

func (m *MessageAddrReq) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageAddrReq) GetMessage() *P2PGetAddr {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageAddrResp struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PAddr     `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessageAddrResp) Reset()         { *m = MessageAddrResp{} }
func (m *MessageAddrResp) String() string { return proto.CompactTextString(m) }
func (*MessageAddrResp) ProtoMessage()    {}
func (*MessageAddrResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{9}
}

func (m *MessageAddrResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageAddrResp.Unmarshal(m, b)
}
func (m *MessageAddrResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageAddrResp.Marshal(b, m, deterministic)
}
func (m *MessageAddrResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageAddrResp.Merge(m, src)
}
func (m *MessageAddrResp) XXX_Size() int {
	return xxx_messageInfo_MessageAddrResp.Size(m)
}
func (m *MessageAddrResp) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageAddrResp.DiscardUnknown(m)
}

var xxx_messageInfo_MessageAddrResp proto.InternalMessageInfo

func (m *MessageAddrResp) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageAddrResp) GetMessage() *P2PAddr {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageAddrList struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PAddrList `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessageAddrList) Reset()         { *m = MessageAddrList{} }
func (m *MessageAddrList) String() string { return proto.CompactTextString(m) }
func (*MessageAddrList) ProtoMessage()    {}
func (*MessageAddrList) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{10}
}

func (m *MessageAddrList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageAddrList.Unmarshal(m, b)
}
func (m *MessageAddrList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageAddrList.Marshal(b, m, deterministic)
}
func (m *MessageAddrList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageAddrList.Merge(m, src)
}
func (m *MessageAddrList) XXX_Size() int {
	return xxx_messageInfo_MessageAddrList.Size(m)
}
func (m *MessageAddrList) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageAddrList.DiscardUnknown(m)
}

var xxx_messageInfo_MessageAddrList proto.InternalMessageInfo

func (m *MessageAddrList) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageAddrList) GetMessage() *P2PAddrList {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageExternalNetReq struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessageExternalNetReq) Reset()         { *m = MessageExternalNetReq{} }
func (m *MessageExternalNetReq) String() string { return proto.CompactTextString(m) }
func (*MessageExternalNetReq) ProtoMessage()    {}
func (*MessageExternalNetReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{11}
}

func (m *MessageExternalNetReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageExternalNetReq.Unmarshal(m, b)
}
func (m *MessageExternalNetReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageExternalNetReq.Marshal(b, m, deterministic)
}
func (m *MessageExternalNetReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageExternalNetReq.Merge(m, src)
}
func (m *MessageExternalNetReq) XXX_Size() int {
	return xxx_messageInfo_MessageExternalNetReq.Size(m)
}
func (m *MessageExternalNetReq) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageExternalNetReq.DiscardUnknown(m)
}

var xxx_messageInfo_MessageExternalNetReq proto.InternalMessageInfo

func (m *MessageExternalNetReq) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

type MessageExternalNetResp struct {
	MessageData          *MessageComm     `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PExternalInfo `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *MessageExternalNetResp) Reset()         { *m = MessageExternalNetResp{} }
func (m *MessageExternalNetResp) String() string { return proto.CompactTextString(m) }
func (*MessageExternalNetResp) ProtoMessage()    {}
func (*MessageExternalNetResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{12}
}

func (m *MessageExternalNetResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageExternalNetResp.Unmarshal(m, b)
}
func (m *MessageExternalNetResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageExternalNetResp.Marshal(b, m, deterministic)
}
func (m *MessageExternalNetResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageExternalNetResp.Merge(m, src)
}
func (m *MessageExternalNetResp) XXX_Size() int {
	return xxx_messageInfo_MessageExternalNetResp.Size(m)
}
func (m *MessageExternalNetResp) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageExternalNetResp.DiscardUnknown(m)
}

var xxx_messageInfo_MessageExternalNetResp proto.InternalMessageInfo

func (m *MessageExternalNetResp) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageExternalNetResp) GetMessage() *P2PExternalInfo {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageGetBlocksReq struct {
	MessageData          *MessageComm  `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PGetBlocks `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *MessageGetBlocksReq) Reset()         { *m = MessageGetBlocksReq{} }
func (m *MessageGetBlocksReq) String() string { return proto.CompactTextString(m) }
func (*MessageGetBlocksReq) ProtoMessage()    {}
func (*MessageGetBlocksReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{13}
}

func (m *MessageGetBlocksReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageGetBlocksReq.Unmarshal(m, b)
}
func (m *MessageGetBlocksReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageGetBlocksReq.Marshal(b, m, deterministic)
}
func (m *MessageGetBlocksReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageGetBlocksReq.Merge(m, src)
}
func (m *MessageGetBlocksReq) XXX_Size() int {
	return xxx_messageInfo_MessageGetBlocksReq.Size(m)
}
func (m *MessageGetBlocksReq) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageGetBlocksReq.DiscardUnknown(m)
}

var xxx_messageInfo_MessageGetBlocksReq proto.InternalMessageInfo

func (m *MessageGetBlocksReq) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageGetBlocksReq) GetMessage() *P2PGetBlocks {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageGetBlocksResp struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *InvDatas    `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessageGetBlocksResp) Reset()         { *m = MessageGetBlocksResp{} }
func (m *MessageGetBlocksResp) String() string { return proto.CompactTextString(m) }
func (*MessageGetBlocksResp) ProtoMessage()    {}
func (*MessageGetBlocksResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{14}
}

func (m *MessageGetBlocksResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageGetBlocksResp.Unmarshal(m, b)
}
func (m *MessageGetBlocksResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageGetBlocksResp.Marshal(b, m, deterministic)
}
func (m *MessageGetBlocksResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageGetBlocksResp.Merge(m, src)
}
func (m *MessageGetBlocksResp) XXX_Size() int {
	return xxx_messageInfo_MessageGetBlocksResp.Size(m)
}
func (m *MessageGetBlocksResp) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageGetBlocksResp.DiscardUnknown(m)
}

var xxx_messageInfo_MessageGetBlocksResp proto.InternalMessageInfo

func (m *MessageGetBlocksResp) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageGetBlocksResp) GetMessage() *InvDatas {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageGetMempoolReq struct {
	MessageData          *MessageComm   `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PGetMempool `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *MessageGetMempoolReq) Reset()         { *m = MessageGetMempoolReq{} }
func (m *MessageGetMempoolReq) String() string { return proto.CompactTextString(m) }
func (*MessageGetMempoolReq) ProtoMessage()    {}
func (*MessageGetMempoolReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{15}
}

func (m *MessageGetMempoolReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageGetMempoolReq.Unmarshal(m, b)
}
func (m *MessageGetMempoolReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageGetMempoolReq.Marshal(b, m, deterministic)
}
func (m *MessageGetMempoolReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageGetMempoolReq.Merge(m, src)
}
func (m *MessageGetMempoolReq) XXX_Size() int {
	return xxx_messageInfo_MessageGetMempoolReq.Size(m)
}
func (m *MessageGetMempoolReq) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageGetMempoolReq.DiscardUnknown(m)
}

var xxx_messageInfo_MessageGetMempoolReq proto.InternalMessageInfo

func (m *MessageGetMempoolReq) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageGetMempoolReq) GetMessage() *P2PGetMempool {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageVersion struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *Versions    `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessageVersion) Reset()         { *m = MessageVersion{} }
func (m *MessageVersion) String() string { return proto.CompactTextString(m) }
func (*MessageVersion) ProtoMessage()    {}
func (*MessageVersion) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{16}
}

func (m *MessageVersion) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageVersion.Unmarshal(m, b)
}
func (m *MessageVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageVersion.Marshal(b, m, deterministic)
}
func (m *MessageVersion) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageVersion.Merge(m, src)
}
func (m *MessageVersion) XXX_Size() int {
	return xxx_messageInfo_MessageVersion.Size(m)
}
func (m *MessageVersion) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageVersion.DiscardUnknown(m)
}

var xxx_messageInfo_MessageVersion proto.InternalMessageInfo

func (m *MessageVersion) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageVersion) GetMessage() *Versions {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageHeaderReq struct {
	MessageData          *MessageComm   `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PGetHeaders `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *MessageHeaderReq) Reset()         { *m = MessageHeaderReq{} }
func (m *MessageHeaderReq) String() string { return proto.CompactTextString(m) }
func (*MessageHeaderReq) ProtoMessage()    {}
func (*MessageHeaderReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{17}
}

func (m *MessageHeaderReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageHeaderReq.Unmarshal(m, b)
}
func (m *MessageHeaderReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageHeaderReq.Marshal(b, m, deterministic)
}
func (m *MessageHeaderReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageHeaderReq.Merge(m, src)
}
func (m *MessageHeaderReq) XXX_Size() int {
	return xxx_messageInfo_MessageHeaderReq.Size(m)
}
func (m *MessageHeaderReq) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageHeaderReq.DiscardUnknown(m)
}

var xxx_messageInfo_MessageHeaderReq proto.InternalMessageInfo

func (m *MessageHeaderReq) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageHeaderReq) GetMessage() *P2PGetHeaders {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageHeaderResp struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *P2PHeaders  `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessageHeaderResp) Reset()         { *m = MessageHeaderResp{} }
func (m *MessageHeaderResp) String() string { return proto.CompactTextString(m) }
func (*MessageHeaderResp) ProtoMessage()    {}
func (*MessageHeaderResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{18}
}

func (m *MessageHeaderResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageHeaderResp.Unmarshal(m, b)
}
func (m *MessageHeaderResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageHeaderResp.Marshal(b, m, deterministic)
}
func (m *MessageHeaderResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageHeaderResp.Merge(m, src)
}
func (m *MessageHeaderResp) XXX_Size() int {
	return xxx_messageInfo_MessageHeaderResp.Size(m)
}
func (m *MessageHeaderResp) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageHeaderResp.DiscardUnknown(m)
}

var xxx_messageInfo_MessageHeaderResp proto.InternalMessageInfo

func (m *MessageHeaderResp) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageHeaderResp) GetMessage() *P2PHeaders {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageInvDataReq struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *InvData     `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessageInvDataReq) Reset()         { *m = MessageInvDataReq{} }
func (m *MessageInvDataReq) String() string { return proto.CompactTextString(m) }
func (*MessageInvDataReq) ProtoMessage()    {}
func (*MessageInvDataReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{19}
}

func (m *MessageInvDataReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageInvDataReq.Unmarshal(m, b)
}
func (m *MessageInvDataReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageInvDataReq.Marshal(b, m, deterministic)
}
func (m *MessageInvDataReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageInvDataReq.Merge(m, src)
}
func (m *MessageInvDataReq) XXX_Size() int {
	return xxx_messageInfo_MessageInvDataReq.Size(m)
}
func (m *MessageInvDataReq) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageInvDataReq.DiscardUnknown(m)
}

var xxx_messageInfo_MessageInvDataReq proto.InternalMessageInfo

func (m *MessageInvDataReq) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageInvDataReq) GetMessage() *InvData {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessagePeerList struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *PeerList    `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessagePeerList) Reset()         { *m = MessagePeerList{} }
func (m *MessagePeerList) String() string { return proto.CompactTextString(m) }
func (*MessagePeerList) ProtoMessage()    {}
func (*MessagePeerList) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{20}
}

func (m *MessagePeerList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagePeerList.Unmarshal(m, b)
}
func (m *MessagePeerList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagePeerList.Marshal(b, m, deterministic)
}
func (m *MessagePeerList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagePeerList.Merge(m, src)
}
func (m *MessagePeerList) XXX_Size() int {
	return xxx_messageInfo_MessagePeerList.Size(m)
}
func (m *MessagePeerList) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagePeerList.DiscardUnknown(m)
}

var xxx_messageInfo_MessagePeerList proto.InternalMessageInfo

func (m *MessagePeerList) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessagePeerList) GetMessage() *PeerList {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessageNetInfo struct {
	MessageData          *MessageComm `protobuf:"bytes,1,opt,name=messageData,proto3" json:"messageData,omitempty"`
	Message              *NodeNetInfo `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessageNetInfo) Reset()         { *m = MessageNetInfo{} }
func (m *MessageNetInfo) String() string { return proto.CompactTextString(m) }
func (*MessageNetInfo) ProtoMessage()    {}
func (*MessageNetInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{21}
}

func (m *MessageNetInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageNetInfo.Unmarshal(m, b)
}
func (m *MessageNetInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageNetInfo.Marshal(b, m, deterministic)
}
func (m *MessageNetInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageNetInfo.Merge(m, src)
}
func (m *MessageNetInfo) XXX_Size() int {
	return xxx_messageInfo_MessageNetInfo.Size(m)
}
func (m *MessageNetInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageNetInfo.DiscardUnknown(m)
}

var xxx_messageInfo_MessageNetInfo proto.InternalMessageInfo

func (m *MessageNetInfo) GetMessageData() *MessageComm {
	if m != nil {
		return m.MessageData
	}
	return nil
}

func (m *MessageNetInfo) GetMessage() *NodeNetInfo {
	if m != nil {
		return m.Message
	}
	return nil
}

type MessagePeersReply struct {
	Common               *MessageComm `protobuf:"bytes,1,opt,name=common,proto3" json:"common,omitempty"`
	PeersReply           *PeersReply  `protobuf:"bytes,2,opt,name=peersReply,proto3" json:"peersReply,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *MessagePeersReply) Reset()         { *m = MessagePeersReply{} }
func (m *MessagePeersReply) String() string { return proto.CompactTextString(m) }
func (*MessagePeersReply) ProtoMessage()    {}
func (*MessagePeersReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{22}
}

func (m *MessagePeersReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagePeersReply.Unmarshal(m, b)
}
func (m *MessagePeersReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagePeersReply.Marshal(b, m, deterministic)
}
func (m *MessagePeersReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagePeersReply.Merge(m, src)
}
func (m *MessagePeersReply) XXX_Size() int {
	return xxx_messageInfo_MessagePeersReply.Size(m)
}
func (m *MessagePeersReply) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagePeersReply.DiscardUnknown(m)
}

var xxx_messageInfo_MessagePeersReply proto.InternalMessageInfo

func (m *MessagePeersReply) GetCommon() *MessageComm {
	if m != nil {
		return m.Common
	}
	return nil
}

func (m *MessagePeersReply) GetPeersReply() *PeersReply {
	if m != nil {
		return m.PeersReply
	}
	return nil
}

type MessageBroadCast struct {
	Common               *MessageComm   `protobuf:"bytes,1,opt,name=common,proto3" json:"common,omitempty"`
	Message              *BroadCastData `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *MessageBroadCast) Reset()         { *m = MessageBroadCast{} }
func (m *MessageBroadCast) String() string { return proto.CompactTextString(m) }
func (*MessageBroadCast) ProtoMessage()    {}
func (*MessageBroadCast) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{23}
}

func (m *MessageBroadCast) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageBroadCast.Unmarshal(m, b)
}
func (m *MessageBroadCast) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageBroadCast.Marshal(b, m, deterministic)
}
func (m *MessageBroadCast) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageBroadCast.Merge(m, src)
}
func (m *MessageBroadCast) XXX_Size() int {
	return xxx_messageInfo_MessageBroadCast.Size(m)
}
func (m *MessageBroadCast) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageBroadCast.DiscardUnknown(m)
}

var xxx_messageInfo_MessageBroadCast proto.InternalMessageInfo

func (m *MessageBroadCast) GetCommon() *MessageComm {
	if m != nil {
		return m.Common
	}
	return nil
}

func (m *MessageBroadCast) GetMessage() *BroadCastData {
	if m != nil {
		return m.Message
	}
	return nil
}

type P2PMessageHeaders struct {
	// shared between all requests
	Version              string   `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	Timestamp            int64    `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Id                   int64    `protobuf:"varint,3,opt,name=id,proto3" json:"id,omitempty"`
	Sign                 []byte   `protobuf:"bytes,5,opt,name=sign,proto3" json:"sign,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *P2PMessageHeaders) Reset()         { *m = P2PMessageHeaders{} }
func (m *P2PMessageHeaders) String() string { return proto.CompactTextString(m) }
func (*P2PMessageHeaders) ProtoMessage()    {}
func (*P2PMessageHeaders) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{24}
}

func (m *P2PMessageHeaders) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_P2PMessageHeaders.Unmarshal(m, b)
}
func (m *P2PMessageHeaders) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_P2PMessageHeaders.Marshal(b, m, deterministic)
}
func (m *P2PMessageHeaders) XXX_Merge(src proto.Message) {
	xxx_messageInfo_P2PMessageHeaders.Merge(m, src)
}
func (m *P2PMessageHeaders) XXX_Size() int {
	return xxx_messageInfo_P2PMessageHeaders.Size(m)
}
func (m *P2PMessageHeaders) XXX_DiscardUnknown() {
	xxx_messageInfo_P2PMessageHeaders.DiscardUnknown(m)
}

var xxx_messageInfo_P2PMessageHeaders proto.InternalMessageInfo

func (m *P2PMessageHeaders) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *P2PMessageHeaders) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *P2PMessageHeaders) GetId() int64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *P2PMessageHeaders) GetSign() []byte {
	if m != nil {
		return m.Sign
	}
	return nil
}

type P2PRequest struct {
	Headers *P2PMessageHeaders `protobuf:"bytes,1,opt,name=headers,proto3" json:"headers,omitempty"`
	// Types that are valid to be assigned to Request:
	//	*P2PRequest_ReqChunkRecords
	//	*P2PRequest_ChunkInfoMsg
	//	*P2PRequest_ChunkInfoList
	//	*P2PRequest_ReqBlocks
	//	*P2PRequest_ReqPeers
	Request              isP2PRequest_Request `protobuf_oneof:"request"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *P2PRequest) Reset()         { *m = P2PRequest{} }
func (m *P2PRequest) String() string { return proto.CompactTextString(m) }
func (*P2PRequest) ProtoMessage()    {}
func (*P2PRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{25}
}

func (m *P2PRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_P2PRequest.Unmarshal(m, b)
}
func (m *P2PRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_P2PRequest.Marshal(b, m, deterministic)
}
func (m *P2PRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_P2PRequest.Merge(m, src)
}
func (m *P2PRequest) XXX_Size() int {
	return xxx_messageInfo_P2PRequest.Size(m)
}
func (m *P2PRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_P2PRequest.DiscardUnknown(m)
}

var xxx_messageInfo_P2PRequest proto.InternalMessageInfo

func (m *P2PRequest) GetHeaders() *P2PMessageHeaders {
	if m != nil {
		return m.Headers
	}
	return nil
}

type isP2PRequest_Request interface {
	isP2PRequest_Request()
}

type P2PRequest_ReqChunkRecords struct {
	ReqChunkRecords *ReqChunkRecords `protobuf:"bytes,2,opt,name=reqChunkRecords,proto3,oneof"`
}

type P2PRequest_ChunkInfoMsg struct {
	ChunkInfoMsg *ChunkInfoMsg `protobuf:"bytes,3,opt,name=chunkInfoMsg,proto3,oneof"`
}

type P2PRequest_ChunkInfoList struct {
	ChunkInfoList *ChunkInfoList `protobuf:"bytes,4,opt,name=chunkInfoList,proto3,oneof"`
}

type P2PRequest_ReqBlocks struct {
	ReqBlocks *ReqBlocks `protobuf:"bytes,5,opt,name=reqBlocks,proto3,oneof"`
}

type P2PRequest_ReqPeers struct {
	ReqPeers *ReqPeers `protobuf:"bytes,6,opt,name=reqPeers,proto3,oneof"`
}

func (*P2PRequest_ReqChunkRecords) isP2PRequest_Request() {}

func (*P2PRequest_ChunkInfoMsg) isP2PRequest_Request() {}

func (*P2PRequest_ChunkInfoList) isP2PRequest_Request() {}

func (*P2PRequest_ReqBlocks) isP2PRequest_Request() {}

func (*P2PRequest_ReqPeers) isP2PRequest_Request() {}

func (m *P2PRequest) GetRequest() isP2PRequest_Request {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *P2PRequest) GetReqChunkRecords() *ReqChunkRecords {
	if x, ok := m.GetRequest().(*P2PRequest_ReqChunkRecords); ok {
		return x.ReqChunkRecords
	}
	return nil
}

func (m *P2PRequest) GetChunkInfoMsg() *ChunkInfoMsg {
	if x, ok := m.GetRequest().(*P2PRequest_ChunkInfoMsg); ok {
		return x.ChunkInfoMsg
	}
	return nil
}

func (m *P2PRequest) GetChunkInfoList() *ChunkInfoList {
	if x, ok := m.GetRequest().(*P2PRequest_ChunkInfoList); ok {
		return x.ChunkInfoList
	}
	return nil
}

func (m *P2PRequest) GetReqBlocks() *ReqBlocks {
	if x, ok := m.GetRequest().(*P2PRequest_ReqBlocks); ok {
		return x.ReqBlocks
	}
	return nil
}

func (m *P2PRequest) GetReqPeers() *ReqPeers {
	if x, ok := m.GetRequest().(*P2PRequest_ReqPeers); ok {
		return x.ReqPeers
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*P2PRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*P2PRequest_ReqChunkRecords)(nil),
		(*P2PRequest_ChunkInfoMsg)(nil),
		(*P2PRequest_ChunkInfoList)(nil),
		(*P2PRequest_ReqBlocks)(nil),
		(*P2PRequest_ReqPeers)(nil),
	}
}

type ReqPeers struct {
	ReferKey             []byte   `protobuf:"bytes,1,opt,name=referKey,proto3" json:"referKey,omitempty"`
	Count                int32    `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqPeers) Reset()         { *m = ReqPeers{} }
func (m *ReqPeers) String() string { return proto.CompactTextString(m) }
func (*ReqPeers) ProtoMessage()    {}
func (*ReqPeers) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{26}
}

func (m *ReqPeers) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReqPeers.Unmarshal(m, b)
}
func (m *ReqPeers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReqPeers.Marshal(b, m, deterministic)
}
func (m *ReqPeers) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReqPeers.Merge(m, src)
}
func (m *ReqPeers) XXX_Size() int {
	return xxx_messageInfo_ReqPeers.Size(m)
}
func (m *ReqPeers) XXX_DiscardUnknown() {
	xxx_messageInfo_ReqPeers.DiscardUnknown(m)
}

var xxx_messageInfo_ReqPeers proto.InternalMessageInfo

func (m *ReqPeers) GetReferKey() []byte {
	if m != nil {
		return m.ReferKey
	}
	return nil
}

func (m *ReqPeers) GetCount() int32 {
	if m != nil {
		return m.Count
	}
	return 0
}

type HashList struct {
	Hashes               [][]byte `protobuf:"bytes,1,rep,name=hashes,proto3" json:"hashes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *HashList) Reset()         { *m = HashList{} }
func (m *HashList) String() string { return proto.CompactTextString(m) }
func (*HashList) ProtoMessage()    {}
func (*HashList) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{27}
}

func (m *HashList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HashList.Unmarshal(m, b)
}
func (m *HashList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HashList.Marshal(b, m, deterministic)
}
func (m *HashList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HashList.Merge(m, src)
}
func (m *HashList) XXX_Size() int {
	return xxx_messageInfo_HashList.Size(m)
}
func (m *HashList) XXX_DiscardUnknown() {
	xxx_messageInfo_HashList.DiscardUnknown(m)
}

var xxx_messageInfo_HashList proto.InternalMessageInfo

func (m *HashList) GetHashes() [][]byte {
	if m != nil {
		return m.Hashes
	}
	return nil
}

type ChunkInfoList struct {
	Items                []*ChunkInfoMsg `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *ChunkInfoList) Reset()         { *m = ChunkInfoList{} }
func (m *ChunkInfoList) String() string { return proto.CompactTextString(m) }
func (*ChunkInfoList) ProtoMessage()    {}
func (*ChunkInfoList) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{28}
}

func (m *ChunkInfoList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChunkInfoList.Unmarshal(m, b)
}
func (m *ChunkInfoList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChunkInfoList.Marshal(b, m, deterministic)
}
func (m *ChunkInfoList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChunkInfoList.Merge(m, src)
}
func (m *ChunkInfoList) XXX_Size() int {
	return xxx_messageInfo_ChunkInfoList.Size(m)
}
func (m *ChunkInfoList) XXX_DiscardUnknown() {
	xxx_messageInfo_ChunkInfoList.DiscardUnknown(m)
}

var xxx_messageInfo_ChunkInfoList proto.InternalMessageInfo

func (m *ChunkInfoList) GetItems() []*ChunkInfoMsg {
	if m != nil {
		return m.Items
	}
	return nil
}

type P2PResponse struct {
	Headers     *P2PMessageHeaders `protobuf:"bytes,1,opt,name=headers,proto3" json:"headers,omitempty"`
	Error       string             `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	CloserPeers []*PeerInfo        `protobuf:"bytes,3,rep,name=closerPeers,proto3" json:"closerPeers,omitempty"`
	// Types that are valid to be assigned to Response:
	//	*P2PResponse_BlockBody
	//	*P2PResponse_BlockHeaders
	//	*P2PResponse_ChunkRecords
	//	*P2PResponse_NodeInfo
	Response             isP2PResponse_Response `protobuf_oneof:"response"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *P2PResponse) Reset()         { *m = P2PResponse{} }
func (m *P2PResponse) String() string { return proto.CompactTextString(m) }
func (*P2PResponse) ProtoMessage()    {}
func (*P2PResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{29}
}

func (m *P2PResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_P2PResponse.Unmarshal(m, b)
}
func (m *P2PResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_P2PResponse.Marshal(b, m, deterministic)
}
func (m *P2PResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_P2PResponse.Merge(m, src)
}
func (m *P2PResponse) XXX_Size() int {
	return xxx_messageInfo_P2PResponse.Size(m)
}
func (m *P2PResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_P2PResponse.DiscardUnknown(m)
}

var xxx_messageInfo_P2PResponse proto.InternalMessageInfo

func (m *P2PResponse) GetHeaders() *P2PMessageHeaders {
	if m != nil {
		return m.Headers
	}
	return nil
}

func (m *P2PResponse) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

func (m *P2PResponse) GetCloserPeers() []*PeerInfo {
	if m != nil {
		return m.CloserPeers
	}
	return nil
}

type isP2PResponse_Response interface {
	isP2PResponse_Response()
}

type P2PResponse_BlockBody struct {
	BlockBody *BlockBody `protobuf:"bytes,5,opt,name=blockBody,proto3,oneof"`
}

type P2PResponse_BlockHeaders struct {
	BlockHeaders *Headers `protobuf:"bytes,6,opt,name=blockHeaders,proto3,oneof"`
}

type P2PResponse_ChunkRecords struct {
	ChunkRecords *ChunkRecords `protobuf:"bytes,7,opt,name=chunkRecords,proto3,oneof"`
}

type P2PResponse_NodeInfo struct {
	NodeInfo *NodeInfo `protobuf:"bytes,8,opt,name=nodeInfo,proto3,oneof"`
}

func (*P2PResponse_BlockBody) isP2PResponse_Response() {}

func (*P2PResponse_BlockHeaders) isP2PResponse_Response() {}

func (*P2PResponse_ChunkRecords) isP2PResponse_Response() {}

func (*P2PResponse_NodeInfo) isP2PResponse_Response() {}

func (m *P2PResponse) GetResponse() isP2PResponse_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *P2PResponse) GetBlockBody() *BlockBody {
	if x, ok := m.GetResponse().(*P2PResponse_BlockBody); ok {
		return x.BlockBody
	}
	return nil
}

func (m *P2PResponse) GetBlockHeaders() *Headers {
	if x, ok := m.GetResponse().(*P2PResponse_BlockHeaders); ok {
		return x.BlockHeaders
	}
	return nil
}

func (m *P2PResponse) GetChunkRecords() *ChunkRecords {
	if x, ok := m.GetResponse().(*P2PResponse_ChunkRecords); ok {
		return x.ChunkRecords
	}
	return nil
}

func (m *P2PResponse) GetNodeInfo() *NodeInfo {
	if x, ok := m.GetResponse().(*P2PResponse_NodeInfo); ok {
		return x.NodeInfo
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*P2PResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*P2PResponse_BlockBody)(nil),
		(*P2PResponse_BlockHeaders)(nil),
		(*P2PResponse_ChunkRecords)(nil),
		(*P2PResponse_NodeInfo)(nil),
	}
}

type NodeInfo struct {
	Answer               bool     `protobuf:"varint,1,opt,name=answer,proto3" json:"answer,omitempty"`
	Height               int64    `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NodeInfo) Reset()         { *m = NodeInfo{} }
func (m *NodeInfo) String() string { return proto.CompactTextString(m) }
func (*NodeInfo) ProtoMessage()    {}
func (*NodeInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{30}
}

func (m *NodeInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeInfo.Unmarshal(m, b)
}
func (m *NodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeInfo.Marshal(b, m, deterministic)
}
func (m *NodeInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeInfo.Merge(m, src)
}
func (m *NodeInfo) XXX_Size() int {
	return xxx_messageInfo_NodeInfo.Size(m)
}
func (m *NodeInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeInfo.DiscardUnknown(m)
}

var xxx_messageInfo_NodeInfo proto.InternalMessageInfo

func (m *NodeInfo) GetAnswer() bool {
	if m != nil {
		return m.Answer
	}
	return false
}

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

type PeerInfo struct {
	ID                   []byte   `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	MultiAddr            [][]byte `protobuf:"bytes,2,rep,name=MultiAddr,proto3" json:"MultiAddr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PeerInfo) Reset()         { *m = PeerInfo{} }
func (m *PeerInfo) String() string { return proto.CompactTextString(m) }
func (*PeerInfo) ProtoMessage()    {}
func (*PeerInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{31}
}

func (m *PeerInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PeerInfo.Unmarshal(m, b)
}
func (m *PeerInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PeerInfo.Marshal(b, m, deterministic)
}
func (m *PeerInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PeerInfo.Merge(m, src)
}
func (m *PeerInfo) XXX_Size() int {
	return xxx_messageInfo_PeerInfo.Size(m)
}
func (m *PeerInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_PeerInfo.DiscardUnknown(m)
}

var xxx_messageInfo_PeerInfo proto.InternalMessageInfo

func (m *PeerInfo) GetID() []byte {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *PeerInfo) GetMultiAddr() [][]byte {
	if m != nil {
		return m.MultiAddr
	}
	return nil
}

type SubTopic struct {
	Topic                string   `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	Module               string   `protobuf:"bytes,2,opt,name=module,proto3" json:"module,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SubTopic) Reset()         { *m = SubTopic{} }
func (m *SubTopic) String() string { return proto.CompactTextString(m) }
func (*SubTopic) ProtoMessage()    {}
func (*SubTopic) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{32}
}

func (m *SubTopic) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SubTopic.Unmarshal(m, b)
}
func (m *SubTopic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SubTopic.Marshal(b, m, deterministic)
}
func (m *SubTopic) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubTopic.Merge(m, src)
}
func (m *SubTopic) XXX_Size() int {
	return xxx_messageInfo_SubTopic.Size(m)
}
func (m *SubTopic) XXX_DiscardUnknown() {
	xxx_messageInfo_SubTopic.DiscardUnknown(m)
}

var xxx_messageInfo_SubTopic proto.InternalMessageInfo

func (m *SubTopic) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *SubTopic) GetModule() string {
	if m != nil {
		return m.Module
	}
	return ""
}

type SubTopicReply struct {
	Status               bool     `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
	Msg                  string   `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SubTopicReply) Reset()         { *m = SubTopicReply{} }
func (m *SubTopicReply) String() string { return proto.CompactTextString(m) }
func (*SubTopicReply) ProtoMessage()    {}
func (*SubTopicReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{33}
}

func (m *SubTopicReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SubTopicReply.Unmarshal(m, b)
}
func (m *SubTopicReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SubTopicReply.Marshal(b, m, deterministic)
}
func (m *SubTopicReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubTopicReply.Merge(m, src)
}
func (m *SubTopicReply) XXX_Size() int {
	return xxx_messageInfo_SubTopicReply.Size(m)
}
func (m *SubTopicReply) XXX_DiscardUnknown() {
	xxx_messageInfo_SubTopicReply.DiscardUnknown(m)
}

var xxx_messageInfo_SubTopicReply proto.InternalMessageInfo

func (m *SubTopicReply) GetStatus() bool {
	if m != nil {
		return m.Status
	}
	return false
}

func (m *SubTopicReply) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

type PublishTopicMsg struct {
	Topic                string   `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	Msg                  []byte   `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PublishTopicMsg) Reset()         { *m = PublishTopicMsg{} }
func (m *PublishTopicMsg) String() string { return proto.CompactTextString(m) }
func (*PublishTopicMsg) ProtoMessage()    {}
func (*PublishTopicMsg) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{34}
}

func (m *PublishTopicMsg) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PublishTopicMsg.Unmarshal(m, b)
}
func (m *PublishTopicMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PublishTopicMsg.Marshal(b, m, deterministic)
}
func (m *PublishTopicMsg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublishTopicMsg.Merge(m, src)
}
func (m *PublishTopicMsg) XXX_Size() int {
	return xxx_messageInfo_PublishTopicMsg.Size(m)
}
func (m *PublishTopicMsg) XXX_DiscardUnknown() {
	xxx_messageInfo_PublishTopicMsg.DiscardUnknown(m)
}

var xxx_messageInfo_PublishTopicMsg proto.InternalMessageInfo

func (m *PublishTopicMsg) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *PublishTopicMsg) GetMsg() []byte {
	if m != nil {
		return m.Msg
	}
	return nil
}

type PublishTopicMsgReply struct {
	Topic                string   `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	Status               bool     `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"`
	Msg                  string   `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PublishTopicMsgReply) Reset()         { *m = PublishTopicMsgReply{} }
func (m *PublishTopicMsgReply) String() string { return proto.CompactTextString(m) }
func (*PublishTopicMsgReply) ProtoMessage()    {}
func (*PublishTopicMsgReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{35}
}

func (m *PublishTopicMsgReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PublishTopicMsgReply.Unmarshal(m, b)
}
func (m *PublishTopicMsgReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PublishTopicMsgReply.Marshal(b, m, deterministic)
}
func (m *PublishTopicMsgReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublishTopicMsgReply.Merge(m, src)
}
func (m *PublishTopicMsgReply) XXX_Size() int {
	return xxx_messageInfo_PublishTopicMsgReply.Size(m)
}
func (m *PublishTopicMsgReply) XXX_DiscardUnknown() {
	xxx_messageInfo_PublishTopicMsgReply.DiscardUnknown(m)
}

var xxx_messageInfo_PublishTopicMsgReply proto.InternalMessageInfo

func (m *PublishTopicMsgReply) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *PublishTopicMsgReply) GetStatus() bool {
	if m != nil {
		return m.Status
	}
	return false
}

func (m *PublishTopicMsgReply) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

//*
// p2p 接收topic消息
type TopicData struct {
	Topic                string   `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	From                 string   `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
	Data                 []byte   `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TopicData) Reset()         { *m = TopicData{} }
func (m *TopicData) String() string { return proto.CompactTextString(m) }
func (*TopicData) ProtoMessage()    {}
func (*TopicData) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{36}
}

func (m *TopicData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TopicData.Unmarshal(m, b)
}
func (m *TopicData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TopicData.Marshal(b, m, deterministic)
}
func (m *TopicData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicData.Merge(m, src)
}
func (m *TopicData) XXX_Size() int {
	return xxx_messageInfo_TopicData.Size(m)
}
func (m *TopicData) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicData.DiscardUnknown(m)
}

var xxx_messageInfo_TopicData proto.InternalMessageInfo

func (m *TopicData) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *TopicData) GetFrom() string {
	if m != nil {
		return m.From
	}
	return ""
}

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

type FetchTopicList struct {
	Module               string   `protobuf:"bytes,1,opt,name=module,proto3" json:"module,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FetchTopicList) Reset()         { *m = FetchTopicList{} }
func (m *FetchTopicList) String() string { return proto.CompactTextString(m) }
func (*FetchTopicList) ProtoMessage()    {}
func (*FetchTopicList) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{37}
}

func (m *FetchTopicList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FetchTopicList.Unmarshal(m, b)
}
func (m *FetchTopicList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FetchTopicList.Marshal(b, m, deterministic)
}
func (m *FetchTopicList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FetchTopicList.Merge(m, src)
}
func (m *FetchTopicList) XXX_Size() int {
	return xxx_messageInfo_FetchTopicList.Size(m)
}
func (m *FetchTopicList) XXX_DiscardUnknown() {
	xxx_messageInfo_FetchTopicList.DiscardUnknown(m)
}

var xxx_messageInfo_FetchTopicList proto.InternalMessageInfo

func (m *FetchTopicList) GetModule() string {
	if m != nil {
		return m.Module
	}
	return ""
}

type TopicList struct {
	Topics               []string `protobuf:"bytes,1,rep,name=topics,proto3" json:"topics,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TopicList) Reset()         { *m = TopicList{} }
func (m *TopicList) String() string { return proto.CompactTextString(m) }
func (*TopicList) ProtoMessage()    {}
func (*TopicList) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{38}
}

func (m *TopicList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TopicList.Unmarshal(m, b)
}
func (m *TopicList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TopicList.Marshal(b, m, deterministic)
}
func (m *TopicList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicList.Merge(m, src)
}
func (m *TopicList) XXX_Size() int {
	return xxx_messageInfo_TopicList.Size(m)
}
func (m *TopicList) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicList.DiscardUnknown(m)
}

var xxx_messageInfo_TopicList proto.InternalMessageInfo

func (m *TopicList) GetTopics() []string {
	if m != nil {
		return m.Topics
	}
	return nil
}

type RemoveTopic struct {
	Topic                string   `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	Module               string   `protobuf:"bytes,2,opt,name=module,proto3" json:"module,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RemoveTopic) Reset()         { *m = RemoveTopic{} }
func (m *RemoveTopic) String() string { return proto.CompactTextString(m) }
func (*RemoveTopic) ProtoMessage()    {}
func (*RemoveTopic) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{39}
}

func (m *RemoveTopic) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RemoveTopic.Unmarshal(m, b)
}
func (m *RemoveTopic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RemoveTopic.Marshal(b, m, deterministic)
}
func (m *RemoveTopic) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveTopic.Merge(m, src)
}
func (m *RemoveTopic) XXX_Size() int {
	return xxx_messageInfo_RemoveTopic.Size(m)
}
func (m *RemoveTopic) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveTopic.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveTopic proto.InternalMessageInfo

func (m *RemoveTopic) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *RemoveTopic) GetModule() string {
	if m != nil {
		return m.Module
	}
	return ""
}

type RemoveTopicReply struct {
	Topic                string   `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	Status               bool     `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"`
	Msg                  string   `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RemoveTopicReply) Reset()         { *m = RemoveTopicReply{} }
func (m *RemoveTopicReply) String() string { return proto.CompactTextString(m) }
func (*RemoveTopicReply) ProtoMessage()    {}
func (*RemoveTopicReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{40}
}

func (m *RemoveTopicReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RemoveTopicReply.Unmarshal(m, b)
}
func (m *RemoveTopicReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RemoveTopicReply.Marshal(b, m, deterministic)
}
func (m *RemoveTopicReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveTopicReply.Merge(m, src)
}
func (m *RemoveTopicReply) XXX_Size() int {
	return xxx_messageInfo_RemoveTopicReply.Size(m)
}
func (m *RemoveTopicReply) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveTopicReply.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveTopicReply proto.InternalMessageInfo

func (m *RemoveTopicReply) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *RemoveTopicReply) GetStatus() bool {
	if m != nil {
		return m.Status
	}
	return false
}

func (m *RemoveTopicReply) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

//*
//dht protos 网络带宽信息
type NetProtocolInfos struct {
	Protoinfo            []*ProtocolInfo `protobuf:"bytes,1,rep,name=protoinfo,proto3" json:"protoinfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *NetProtocolInfos) Reset()         { *m = NetProtocolInfos{} }
func (m *NetProtocolInfos) String() string { return proto.CompactTextString(m) }
func (*NetProtocolInfos) ProtoMessage()    {}
func (*NetProtocolInfos) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{41}
}

func (m *NetProtocolInfos) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NetProtocolInfos.Unmarshal(m, b)
}
func (m *NetProtocolInfos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NetProtocolInfos.Marshal(b, m, deterministic)
}
func (m *NetProtocolInfos) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetProtocolInfos.Merge(m, src)
}
func (m *NetProtocolInfos) XXX_Size() int {
	return xxx_messageInfo_NetProtocolInfos.Size(m)
}
func (m *NetProtocolInfos) XXX_DiscardUnknown() {
	xxx_messageInfo_NetProtocolInfos.DiscardUnknown(m)
}

var xxx_messageInfo_NetProtocolInfos proto.InternalMessageInfo

func (m *NetProtocolInfos) GetProtoinfo() []*ProtocolInfo {
	if m != nil {
		return m.Protoinfo
	}
	return nil
}

type ProtocolInfo struct {
	Protocol             string   `protobuf:"bytes,1,opt,name=protocol,proto3" json:"protocol,omitempty"`
	Ratein               string   `protobuf:"bytes,2,opt,name=ratein,proto3" json:"ratein,omitempty"`
	Rateout              string   `protobuf:"bytes,3,opt,name=rateout,proto3" json:"rateout,omitempty"`
	Ratetotal            string   `protobuf:"bytes,4,opt,name=ratetotal,proto3" json:"ratetotal,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ProtocolInfo) Reset()         { *m = ProtocolInfo{} }
func (m *ProtocolInfo) String() string { return proto.CompactTextString(m) }
func (*ProtocolInfo) ProtoMessage()    {}
func (*ProtocolInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_d81e96199caf00d1, []int{42}
}

func (m *ProtocolInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProtocolInfo.Unmarshal(m, b)
}
func (m *ProtocolInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProtocolInfo.Marshal(b, m, deterministic)
}
func (m *ProtocolInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProtocolInfo.Merge(m, src)
}
func (m *ProtocolInfo) XXX_Size() int {
	return xxx_messageInfo_ProtocolInfo.Size(m)
}
func (m *ProtocolInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ProtocolInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ProtocolInfo proto.InternalMessageInfo

func (m *ProtocolInfo) GetProtocol() string {
	if m != nil {
		return m.Protocol
	}
	return ""
}

func (m *ProtocolInfo) GetRatein() string {
	if m != nil {
		return m.Ratein
	}
	return ""
}

func (m *ProtocolInfo) GetRateout() string {
	if m != nil {
		return m.Rateout
	}
	return ""
}

func (m *ProtocolInfo) GetRatetotal() string {
	if m != nil {
		return m.Ratetotal
	}
	return ""
}

func init() {
	proto.RegisterType((*MessageComm)(nil), "types.MessageComm")
	proto.RegisterType((*MessageUtil)(nil), "types.MessageUtil")
	proto.RegisterType((*MessagePeerInfoReq)(nil), "types.MessagePeerInfoReq")
	proto.RegisterType((*MessagePeerInfoResp)(nil), "types.MessagePeerInfoResp")
	proto.RegisterType((*MessageP2PVersionReq)(nil), "types.MessageP2PVersionReq")
	proto.RegisterType((*MessageP2PVersionResp)(nil), "types.MessageP2PVersionResp")
	proto.RegisterType((*MessagePingReq)(nil), "types.MessagePingReq")
	proto.RegisterType((*MessagePingResp)(nil), "types.MessagePingResp")
	proto.RegisterType((*MessageAddrReq)(nil), "types.MessageAddrReq")
	proto.RegisterType((*MessageAddrResp)(nil), "types.MessageAddrResp")
	proto.RegisterType((*MessageAddrList)(nil), "types.MessageAddrList")
	proto.RegisterType((*MessageExternalNetReq)(nil), "types.MessageExternalNetReq")
	proto.RegisterType((*MessageExternalNetResp)(nil), "types.MessageExternalNetResp")
	proto.RegisterType((*MessageGetBlocksReq)(nil), "types.MessageGetBlocksReq")
	proto.RegisterType((*MessageGetBlocksResp)(nil), "types.MessageGetBlocksResp")
	proto.RegisterType((*MessageGetMempoolReq)(nil), "types.MessageGetMempoolReq")
	proto.RegisterType((*MessageVersion)(nil), "types.MessageVersion")
	proto.RegisterType((*MessageHeaderReq)(nil), "types.MessageHeaderReq")
	proto.RegisterType((*MessageHeaderResp)(nil), "types.MessageHeaderResp")
	proto.RegisterType((*MessageInvDataReq)(nil), "types.MessageInvDataReq")
	proto.RegisterType((*MessagePeerList)(nil), "types.MessagePeerList")
	proto.RegisterType((*MessageNetInfo)(nil), "types.MessageNetInfo")
	proto.RegisterType((*MessagePeersReply)(nil), "types.MessagePeersReply")
	proto.RegisterType((*MessageBroadCast)(nil), "types.MessageBroadCast")
	proto.RegisterType((*P2PMessageHeaders)(nil), "types.P2PMessageHeaders")
	proto.RegisterType((*P2PRequest)(nil), "types.P2PRequest")
	proto.RegisterType((*ReqPeers)(nil), "types.ReqPeers")
	proto.RegisterType((*HashList)(nil), "types.HashList")
	proto.RegisterType((*ChunkInfoList)(nil), "types.ChunkInfoList")
	proto.RegisterType((*P2PResponse)(nil), "types.P2PResponse")
	proto.RegisterType((*NodeInfo)(nil), "types.NodeInfo")
	proto.RegisterType((*PeerInfo)(nil), "types.PeerInfo")
	proto.RegisterType((*SubTopic)(nil), "types.SubTopic")
	proto.RegisterType((*SubTopicReply)(nil), "types.SubTopicReply")
	proto.RegisterType((*PublishTopicMsg)(nil), "types.PublishTopicMsg")
	proto.RegisterType((*PublishTopicMsgReply)(nil), "types.PublishTopicMsgReply")
	proto.RegisterType((*TopicData)(nil), "types.TopicData")
	proto.RegisterType((*FetchTopicList)(nil), "types.FetchTopicList")
	proto.RegisterType((*TopicList)(nil), "types.TopicList")
	proto.RegisterType((*RemoveTopic)(nil), "types.RemoveTopic")
	proto.RegisterType((*RemoveTopicReply)(nil), "types.RemoveTopicReply")
	proto.RegisterType((*NetProtocolInfos)(nil), "types.NetProtocolInfos")
	proto.RegisterType((*ProtocolInfo)(nil), "types.ProtocolInfo")
}

func init() {
	proto.RegisterFile("p2pnext.proto", fileDescriptor_d81e96199caf00d1)
}

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