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

package bhome_msg

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type BHAddress struct {
	MqId    uint64 `protobuf:"varint,1,opt,name=mq_id,json=mqId,proto3" json:"mq_id,omitempty"`
	AbsAddr int64  `protobuf:"varint,2,opt,name=abs_addr,json=absAddr,proto3" json:"abs_addr,omitempty"`
	Ip      []byte `protobuf:"bytes,3,opt,name=ip,proto3" json:"ip,omitempty"`
	Port    int32  `protobuf:"varint,4,opt,name=port,proto3" json:"port,omitempty"`
}

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

var xxx_messageInfo_BHAddress proto.InternalMessageInfo

func (m *BHAddress) GetMqId() uint64 {
	if m != nil {
		return m.MqId
	}
	return 0
}

func (m *BHAddress) GetAbsAddr() int64 {
	if m != nil {
		return m.AbsAddr
	}
	return 0
}

func (m *BHAddress) GetIp() []byte {
	if m != nil {
		return m.Ip
	}
	return nil
}

func (m *BHAddress) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

type ProcInfo struct {
	ProcId      []byte `protobuf:"bytes,1,opt,name=proc_id,json=procId,proto3" json:"proc_id,omitempty"`
	Name        []byte `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	PublicInfo  []byte `protobuf:"bytes,3,opt,name=public_info,json=publicInfo,proto3" json:"public_info,omitempty"`
	PrivateInfo []byte `protobuf:"bytes,4,opt,name=private_info,json=privateInfo,proto3" json:"private_info,omitempty"`
}

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

var xxx_messageInfo_ProcInfo proto.InternalMessageInfo

func (m *ProcInfo) GetProcId() []byte {
	if m != nil {
		return m.ProcId
	}
	return nil
}

func (m *ProcInfo) GetName() []byte {
	if m != nil {
		return m.Name
	}
	return nil
}

func (m *ProcInfo) GetPublicInfo() []byte {
	if m != nil {
		return m.PublicInfo
	}
	return nil
}

func (m *ProcInfo) GetPrivateInfo() []byte {
	if m != nil {
		return m.PrivateInfo
	}
	return nil
}

type MsgTopicList struct {
	TopicList [][]byte `protobuf:"bytes,1,rep,name=topic_list,json=topicList,proto3" json:"topic_list,omitempty"`
}

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

var xxx_messageInfo_MsgTopicList proto.InternalMessageInfo

func (m *MsgTopicList) GetTopicList() [][]byte {
	if m != nil {
		return m.TopicList
	}
	return nil
}

type MsgPublish struct {
	Topic []byte `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	Data  []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}

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

var xxx_messageInfo_MsgPublish proto.InternalMessageInfo

func (m *MsgPublish) GetTopic() []byte {
	if m != nil {
		return m.Topic
	}
	return nil
}

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

type MsgCommonReply struct {
	Errmsg *ErrorMsg `protobuf:"bytes,1,opt,name=errmsg,proto3" json:"errmsg,omitempty"`
}

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

var xxx_messageInfo_MsgCommonReply proto.InternalMessageInfo

func (m *MsgCommonReply) GetErrmsg() *ErrorMsg {
	if m != nil {
		return m.Errmsg
	}
	return nil
}

type MsgRequestTopic struct {
	Topic []byte `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	Data  []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}

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

var xxx_messageInfo_MsgRequestTopic proto.InternalMessageInfo

func (m *MsgRequestTopic) GetTopic() []byte {
	if m != nil {
		return m.Topic
	}
	return nil
}

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

type MsgRequestTopicReply struct {
	Errmsg *ErrorMsg `protobuf:"bytes,1,opt,name=errmsg,proto3" json:"errmsg,omitempty"`
	Data   []byte    `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}

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

var xxx_messageInfo_MsgRequestTopicReply proto.InternalMessageInfo

func (m *MsgRequestTopicReply) GetErrmsg() *ErrorMsg {
	if m != nil {
		return m.Errmsg
	}
	return nil
}

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

type MsgRegister struct {
	Proc *ProcInfo `protobuf:"bytes,1,opt,name=proc,proto3" json:"proc,omitempty"`
}

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

var xxx_messageInfo_MsgRegister proto.InternalMessageInfo

func (m *MsgRegister) GetProc() *ProcInfo {
	if m != nil {
		return m.Proc
	}
	return nil
}

type MsgUnregister struct {
	Proc *ProcInfo `protobuf:"bytes,1,opt,name=proc,proto3" json:"proc,omitempty"`
}

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

var xxx_messageInfo_MsgUnregister proto.InternalMessageInfo

func (m *MsgUnregister) GetProc() *ProcInfo {
	if m != nil {
		return m.Proc
	}
	return nil
}

type MsgHeartbeat struct {
	Proc *ProcInfo `protobuf:"bytes,1,opt,name=proc,proto3" json:"proc,omitempty"`
}

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

var xxx_messageInfo_MsgHeartbeat proto.InternalMessageInfo

func (m *MsgHeartbeat) GetProc() *ProcInfo {
	if m != nil {
		return m.Proc
	}
	return nil
}

type MsgQueryTopic struct {
	Topic []byte `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
}

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

var xxx_messageInfo_MsgQueryTopic proto.InternalMessageInfo

func (m *MsgQueryTopic) GetTopic() []byte {
	if m != nil {
		return m.Topic
	}
	return nil
}

type MsgQueryTopicReply struct {
	Errmsg      *ErrorMsg                           `protobuf:"bytes,1,opt,name=errmsg,proto3" json:"errmsg,omitempty"`
	NodeAddress []*MsgQueryTopicReply_BHNodeAddress `protobuf:"bytes,2,rep,name=node_address,json=nodeAddress,proto3" json:"node_address,omitempty"`
}

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

var xxx_messageInfo_MsgQueryTopicReply proto.InternalMessageInfo

func (m *MsgQueryTopicReply) GetErrmsg() *ErrorMsg {
	if m != nil {
		return m.Errmsg
	}
	return nil
}

func (m *MsgQueryTopicReply) GetNodeAddress() []*MsgQueryTopicReply_BHNodeAddress {
	if m != nil {
		return m.NodeAddress
	}
	return nil
}

type MsgQueryTopicReply_BHNodeAddress struct {
	ProcId []byte     `protobuf:"bytes,1,opt,name=proc_id,json=procId,proto3" json:"proc_id,omitempty"`
	Addr   *BHAddress `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
}

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

var xxx_messageInfo_MsgQueryTopicReply_BHNodeAddress proto.InternalMessageInfo

func (m *MsgQueryTopicReply_BHNodeAddress) GetProcId() []byte {
	if m != nil {
		return m.ProcId
	}
	return nil
}

func (m *MsgQueryTopicReply_BHNodeAddress) GetAddr() *BHAddress {
	if m != nil {
		return m.Addr
	}
	return nil
}

type MsgQueryProc struct {
	ProcId []byte `protobuf:"bytes,1,opt,name=proc_id,json=procId,proto3" json:"proc_id,omitempty"`
}

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

var xxx_messageInfo_MsgQueryProc proto.InternalMessageInfo

func (m *MsgQueryProc) GetProcId() []byte {
	if m != nil {
		return m.ProcId
	}
	return nil
}

type MsgQueryProcReply struct {
	Errmsg   *ErrorMsg                 `protobuf:"bytes,1,opt,name=errmsg,proto3" json:"errmsg,omitempty"`
	ProcList []*MsgQueryProcReply_Info `protobuf:"bytes,2,rep,name=proc_list,json=procList,proto3" json:"proc_list,omitempty"`
}

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

var xxx_messageInfo_MsgQueryProcReply proto.InternalMessageInfo

func (m *MsgQueryProcReply) GetErrmsg() *ErrorMsg {
	if m != nil {
		return m.Errmsg
	}
	return nil
}

func (m *MsgQueryProcReply) GetProcList() []*MsgQueryProcReply_Info {
	if m != nil {
		return m.ProcList
	}
	return nil
}

type MsgQueryProcReply_Info struct {
	Proc     *ProcInfo     `protobuf:"bytes,1,opt,name=proc,proto3" json:"proc,omitempty"`
	Online   bool          `protobuf:"varint,2,opt,name=online,proto3" json:"online,omitempty"`
	Service  *MsgTopicList `protobuf:"bytes,3,opt,name=service,proto3" json:"service,omitempty"`
	LocalSub *MsgTopicList `protobuf:"bytes,4,opt,name=local_sub,json=localSub,proto3" json:"local_sub,omitempty"`
	NetSub   *MsgTopicList `protobuf:"bytes,5,opt,name=net_sub,json=netSub,proto3" json:"net_sub,omitempty"`
}

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

var xxx_messageInfo_MsgQueryProcReply_Info proto.InternalMessageInfo

func (m *MsgQueryProcReply_Info) GetProc() *ProcInfo {
	if m != nil {
		return m.Proc
	}
	return nil
}

func (m *MsgQueryProcReply_Info) GetOnline() bool {
	if m != nil {
		return m.Online
	}
	return false
}

func (m *MsgQueryProcReply_Info) GetService() *MsgTopicList {
	if m != nil {
		return m.Service
	}
	return nil
}

func (m *MsgQueryProcReply_Info) GetLocalSub() *MsgTopicList {
	if m != nil {
		return m.LocalSub
	}
	return nil
}

func (m *MsgQueryProcReply_Info) GetNetSub() *MsgTopicList {
	if m != nil {
		return m.NetSub
	}
	return nil
}

func init() {
	proto.RegisterType((*BHAddress)(nil), "bhome_msg.BHAddress")
	proto.RegisterType((*ProcInfo)(nil), "bhome_msg.ProcInfo")
	proto.RegisterType((*MsgTopicList)(nil), "bhome_msg.MsgTopicList")
	proto.RegisterType((*MsgPublish)(nil), "bhome_msg.MsgPublish")
	proto.RegisterType((*MsgCommonReply)(nil), "bhome_msg.MsgCommonReply")
	proto.RegisterType((*MsgRequestTopic)(nil), "bhome_msg.MsgRequestTopic")
	proto.RegisterType((*MsgRequestTopicReply)(nil), "bhome_msg.MsgRequestTopicReply")
	proto.RegisterType((*MsgRegister)(nil), "bhome_msg.MsgRegister")
	proto.RegisterType((*MsgUnregister)(nil), "bhome_msg.MsgUnregister")
	proto.RegisterType((*MsgHeartbeat)(nil), "bhome_msg.MsgHeartbeat")
	proto.RegisterType((*MsgQueryTopic)(nil), "bhome_msg.MsgQueryTopic")
	proto.RegisterType((*MsgQueryTopicReply)(nil), "bhome_msg.MsgQueryTopicReply")
	proto.RegisterType((*MsgQueryTopicReply_BHNodeAddress)(nil), "bhome_msg.MsgQueryTopicReply.BHNodeAddress")
	proto.RegisterType((*MsgQueryProc)(nil), "bhome_msg.MsgQueryProc")
	proto.RegisterType((*MsgQueryProcReply)(nil), "bhome_msg.MsgQueryProcReply")
	proto.RegisterType((*MsgQueryProcReply_Info)(nil), "bhome_msg.MsgQueryProcReply.Info")
}

func init() { proto.RegisterFile("bhome_msg_api.proto", fileDescriptor_a49c9c1f511a168c) }

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

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

func (m *BHAddress) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.MqId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.MqId))
	}
	if m.AbsAddr != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.AbsAddr))
	}
	if len(m.Ip) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.Ip)))
		i += copy(dAtA[i:], m.Ip)
	}
	if m.Port != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Port))
	}
	return i, nil
}

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

func (m *ProcInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ProcId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.ProcId)))
		i += copy(dAtA[i:], m.ProcId)
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.PublicInfo) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.PublicInfo)))
		i += copy(dAtA[i:], m.PublicInfo)
	}
	if len(m.PrivateInfo) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.PrivateInfo)))
		i += copy(dAtA[i:], m.PrivateInfo)
	}
	return i, nil
}

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

func (m *MsgTopicList) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.TopicList) > 0 {
		for _, b := range m.TopicList {
			dAtA[i] = 0xa
			i++
			i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	return i, nil
}

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

func (m *MsgPublish) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Topic) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.Topic)))
		i += copy(dAtA[i:], m.Topic)
	}
	if len(m.Data) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.Data)))
		i += copy(dAtA[i:], m.Data)
	}
	return i, nil
}

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

func (m *MsgCommonReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Errmsg != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Errmsg.Size()))
		n1, err1 := m.Errmsg.MarshalTo(dAtA[i:])
		if err1 != nil {
			return 0, err1
		}
		i += n1
	}
	return i, nil
}

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

func (m *MsgRequestTopic) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Topic) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.Topic)))
		i += copy(dAtA[i:], m.Topic)
	}
	if len(m.Data) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.Data)))
		i += copy(dAtA[i:], m.Data)
	}
	return i, nil
}

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

func (m *MsgRequestTopicReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Errmsg != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Errmsg.Size()))
		n2, err2 := m.Errmsg.MarshalTo(dAtA[i:])
		if err2 != nil {
			return 0, err2
		}
		i += n2
	}
	if len(m.Data) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.Data)))
		i += copy(dAtA[i:], m.Data)
	}
	return i, nil
}

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

func (m *MsgRegister) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Proc != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Proc.Size()))
		n3, err3 := m.Proc.MarshalTo(dAtA[i:])
		if err3 != nil {
			return 0, err3
		}
		i += n3
	}
	return i, nil
}

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

func (m *MsgUnregister) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Proc != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Proc.Size()))
		n4, err4 := m.Proc.MarshalTo(dAtA[i:])
		if err4 != nil {
			return 0, err4
		}
		i += n4
	}
	return i, nil
}

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

func (m *MsgHeartbeat) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Proc != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Proc.Size()))
		n5, err5 := m.Proc.MarshalTo(dAtA[i:])
		if err5 != nil {
			return 0, err5
		}
		i += n5
	}
	return i, nil
}

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

func (m *MsgQueryTopic) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Topic) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.Topic)))
		i += copy(dAtA[i:], m.Topic)
	}
	return i, nil
}

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

func (m *MsgQueryTopicReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Errmsg != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Errmsg.Size()))
		n6, err6 := m.Errmsg.MarshalTo(dAtA[i:])
		if err6 != nil {
			return 0, err6
		}
		i += n6
	}
	if len(m.NodeAddress) > 0 {
		for _, msg := range m.NodeAddress {
			dAtA[i] = 0x12
			i++
			i = encodeVarintBhomeMsgApi(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *MsgQueryTopicReply_BHNodeAddress) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ProcId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.ProcId)))
		i += copy(dAtA[i:], m.ProcId)
	}
	if m.Addr != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Addr.Size()))
		n7, err7 := m.Addr.MarshalTo(dAtA[i:])
		if err7 != nil {
			return 0, err7
		}
		i += n7
	}
	return i, nil
}

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

func (m *MsgQueryProc) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ProcId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.ProcId)))
		i += copy(dAtA[i:], m.ProcId)
	}
	return i, nil
}

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

func (m *MsgQueryProcReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Errmsg != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Errmsg.Size()))
		n8, err8 := m.Errmsg.MarshalTo(dAtA[i:])
		if err8 != nil {
			return 0, err8
		}
		i += n8
	}
	if len(m.ProcList) > 0 {
		for _, msg := range m.ProcList {
			dAtA[i] = 0x12
			i++
			i = encodeVarintBhomeMsgApi(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *MsgQueryProcReply_Info) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Proc != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Proc.Size()))
		n9, err9 := m.Proc.MarshalTo(dAtA[i:])
		if err9 != nil {
			return 0, err9
		}
		i += n9
	}
	if m.Online {
		dAtA[i] = 0x10
		i++
		if m.Online {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Service != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Service.Size()))
		n10, err10 := m.Service.MarshalTo(dAtA[i:])
		if err10 != nil {
			return 0, err10
		}
		i += n10
	}
	if m.LocalSub != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.LocalSub.Size()))
		n11, err11 := m.LocalSub.MarshalTo(dAtA[i:])
		if err11 != nil {
			return 0, err11
		}
		i += n11
	}
	if m.NetSub != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.NetSub.Size()))
		n12, err12 := m.NetSub.MarshalTo(dAtA[i:])
		if err12 != nil {
			return 0, err12
		}
		i += n12
	}
	return i, nil
}

func encodeVarintBhomeMsgApi(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *BHAddress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MqId != 0 {
		n += 1 + sovBhomeMsgApi(uint64(m.MqId))
	}
	if m.AbsAddr != 0 {
		n += 1 + sovBhomeMsgApi(uint64(m.AbsAddr))
	}
	l = len(m.Ip)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	if m.Port != 0 {
		n += 1 + sovBhomeMsgApi(uint64(m.Port))
	}
	return n
}

func (m *ProcInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProcId)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	l = len(m.PublicInfo)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	l = len(m.PrivateInfo)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

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

func (m *MsgPublish) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Topic)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

func (m *MsgCommonReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errmsg != nil {
		l = m.Errmsg.Size()
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

func (m *MsgRequestTopic) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Topic)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

func (m *MsgRequestTopicReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errmsg != nil {
		l = m.Errmsg.Size()
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

func (m *MsgRegister) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Proc != nil {
		l = m.Proc.Size()
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

func (m *MsgUnregister) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Proc != nil {
		l = m.Proc.Size()
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

func (m *MsgHeartbeat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Proc != nil {
		l = m.Proc.Size()
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

func (m *MsgQueryTopic) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Topic)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

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

func (m *MsgQueryTopicReply_BHNodeAddress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProcId)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	if m.Addr != nil {
		l = m.Addr.Size()
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

func (m *MsgQueryProc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProcId)
	if l > 0 {
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

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

func (m *MsgQueryProcReply_Info) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Proc != nil {
		l = m.Proc.Size()
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	if m.Online {
		n += 2
	}
	if m.Service != nil {
		l = m.Service.Size()
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	if m.LocalSub != nil {
		l = m.LocalSub.Size()
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	if m.NetSub != nil {
		l = m.NetSub.Size()
		n += 1 + l + sovBhomeMsgApi(uint64(l))
	}
	return n
}

func sovBhomeMsgApi(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozBhomeMsgApi(x uint64) (n int) {
	return sovBhomeMsgApi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *BHAddress) 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 ErrIntOverflowBhomeMsgApi
			}
			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: BHAddress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BHAddress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MqId", wireType)
			}
			m.MqId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBhomeMsgApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MqId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AbsAddr", wireType)
			}
			m.AbsAddr = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBhomeMsgApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AbsAddr |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBhomeMsgApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ip = append(m.Ip[:0], dAtA[iNdEx:postIndex]...)
			if m.Ip == nil {
				m.Ip = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBhomeMsgApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBhomeMsgApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgQueryProcReply_Info) 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 ErrIntOverflowBhomeMsgApi
			}
			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: Info: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Info: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proc", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBhomeMsgApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Proc == nil {
				m.Proc = &ProcInfo{}
			}
			if err := m.Proc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Online", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBhomeMsgApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Online = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBhomeMsgApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Service == nil {
				m.Service = &MsgTopicList{}
			}
			if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalSub", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBhomeMsgApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LocalSub == nil {
				m.LocalSub = &MsgTopicList{}
			}
			if err := m.LocalSub.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetSub", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBhomeMsgApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NetSub == nil {
				m.NetSub = &MsgTopicList{}
			}
			if err := m.NetSub.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBhomeMsgApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBhomeMsgApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipBhomeMsgApi(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowBhomeMsgApi
			}
			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, ErrIntOverflowBhomeMsgApi
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowBhomeMsgApi
				}
				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, ErrInvalidLengthBhomeMsgApi
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthBhomeMsgApi
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowBhomeMsgApi
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipBhomeMsgApi(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthBhomeMsgApi
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthBhomeMsgApi = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBhomeMsgApi   = fmt.Errorf("proto: integer overflow")
)