hub.pb.go

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

package hub

import (
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	node "github.com/bittorrent/go-btfs-common/protos/node"
	_ "github.com/gogo/protobuf/types"
	golang_proto "github.com/golang/protobuf/proto"
	_ "github.com/tron-us/protobuf/gogoproto"
	proto "github.com/tron-us/protobuf/proto"
	github_com_tron_us_protobuf_types "github.com/tron-us/protobuf/types"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

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

type ResponseCode int32

const (
	ResponseCode_SUCCESS                ResponseCode = 0
	ResponseCode_SIGNATURE_FORMAT_ERROR ResponseCode = 1
	ResponseCode_COMPUTE_ADDRESS_ERROR  ResponseCode = 2
	ResponseCode_TIMEOUT_ERROR          ResponseCode = 3
	ResponseCode_OTHER_ERROR            ResponseCode = 20
)

var ResponseCode_name = map[int32]string{
	0:  "SUCCESS",
	1:  "SIGNATURE_FORMAT_ERROR",
	2:  "COMPUTE_ADDRESS_ERROR",
	3:  "TIMEOUT_ERROR",
	20: "OTHER_ERROR",
}

var ResponseCode_value = map[string]int32{
	"SUCCESS":                0,
	"SIGNATURE_FORMAT_ERROR": 1,
	"COMPUTE_ADDRESS_ERROR":  2,
	"TIMEOUT_ERROR":          3,
	"OTHER_ERROR":            20,
}

func (x ResponseCode) String() string {
	return proto.EnumName(ResponseCode_name, int32(x))
}

func (ResponseCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c704b5990190a69f, []int{0}
}

type HostsReq_Mode int32

const (
	HostsReq_SCORE   HostsReq_Mode = 0
	HostsReq_GEO     HostsReq_Mode = 1
	HostsReq_REP     HostsReq_Mode = 2
	HostsReq_PRICE   HostsReq_Mode = 3
	HostsReq_SPEED   HostsReq_Mode = 4
	HostsReq_TESTNET HostsReq_Mode = 5
)

var HostsReq_Mode_name = map[int32]string{
	0: "SCORE",
	1: "GEO",
	2: "REP",
	3: "PRICE",
	4: "SPEED",
	5: "TESTNET",
}

var HostsReq_Mode_value = map[string]int32{
	"SCORE":   0,
	"GEO":     1,
	"REP":     2,
	"PRICE":   3,
	"SPEED":   4,
	"TESTNET": 5,
}

func (x HostsReq_Mode) String() string {
	return proto.EnumName(HostsReq_Mode_name, int32(x))
}

func (HostsReq_Mode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c704b5990190a69f, []int{4, 0}
}

type RecycleReq_ESIndex int32

const (
	RecycleReq_NODES         RecycleReq_ESIndex = 0
	RecycleReq_NETWORK       RecycleReq_ESIndex = 1
	RecycleReq_TESTNET_NODES RecycleReq_ESIndex = 2
)

var RecycleReq_ESIndex_name = map[int32]string{
	0: "NODES",
	1: "NETWORK",
	2: "TESTNET_NODES",
}

var RecycleReq_ESIndex_value = map[string]int32{
	"NODES":         0,
	"NETWORK":       1,
	"TESTNET_NODES": 2,
}

func (x RecycleReq_ESIndex) String() string {
	return proto.EnumName(RecycleReq_ESIndex_name, int32(x))
}

func (RecycleReq_ESIndex) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c704b5990190a69f, []int{11, 0}
}

type NodesReq struct {
	NodeId               []string `protobuf:"bytes,1,rep,name=node_id,json=nodeId,proto3" json:"node_id,omitempty" pg:"node_id"`
	RequesterId          string   `protobuf:"bytes,2,opt,name=requester_id,json=requesterId,proto3" json:"requester_id,omitempty" pg:"requester_id"`
	Signature            []byte   `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty" pg:"signature"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_NodesReq proto.InternalMessageInfo

func (m *NodesReq) GetNodeId() []string {
	if m != nil {
		return m.NodeId
	}
	return nil
}

func (m *NodesReq) GetRequesterId() string {
	if m != nil {
		return m.RequesterId
	}
	return ""
}

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

func (*NodesReq) XXX_MessageName() string {
	return "hub.NodesReq"
}

type SettingsReq struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" pg:"id"`
	RespSize             int32    `protobuf:"varint,2,opt,name=resp_size,json=respSize,proto3" json:"resp_size,omitempty" pg:"resp_size"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SettingsReq proto.InternalMessageInfo

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

func (m *SettingsReq) GetRespSize() int32 {
	if m != nil {
		return m.RespSize
	}
	return 0
}

func (*SettingsReq) XXX_MessageName() string {
	return "hub.SettingsReq"
}

type SettingsResp struct {
	Code                 ResponseCode  `protobuf:"varint,1,opt,name=code,proto3,enum=hub.ResponseCode" json:"code,omitempty" pg:"code"`
	Message              string        `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty" pg:"message"`
	ResponseTime         time.Time     `protobuf:"bytes,3,opt,name=response_time,json=responseTime,proto3,stdtime" json:"response_time" pg:"response_time"`
	SettingsData         *SettingsData `protobuf:"bytes,4,opt,name=settings_data,json=settingsData,proto3" json:"settings_data,omitempty" pg:"settings_data"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-" pg:"-"`
	XXX_unrecognized     []byte        `json:"-" pg:"-"`
	XXX_sizecache        int32         `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SettingsResp proto.InternalMessageInfo

func (m *SettingsResp) GetCode() ResponseCode {
	if m != nil {
		return m.Code
	}
	return ResponseCode_SUCCESS
}

func (m *SettingsResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *SettingsResp) GetResponseTime() time.Time {
	if m != nil {
		return m.ResponseTime
	}
	return time.Time{}
}

func (m *SettingsResp) GetSettingsData() *SettingsData {
	if m != nil {
		return m.SettingsData
	}
	return nil
}

func (*SettingsResp) XXX_MessageName() string {
	return "hub.SettingsResp"
}

type SettingsData struct {
	StoragePriceAsk      float64  `protobuf:"fixed64,1,opt,name=storage_price_ask,json=storagePriceAsk,proto3" json:"storage_price_ask,omitempty" pg:"storage_price_ask"`
	BandwidthPriceAsk    float64  `protobuf:"fixed64,2,opt,name=bandwidth_price_ask,json=bandwidthPriceAsk,proto3" json:"bandwidth_price_ask,omitempty" pg:"bandwidth_price_ask"`
	StorageTimeMin       float64  `protobuf:"fixed64,3,opt,name=storage_time_min,json=storageTimeMin,proto3" json:"storage_time_min,omitempty" pg:"storage_time_min"`
	BandwidthLimit       float64  `protobuf:"fixed64,4,opt,name=bandwidth_limit,json=bandwidthLimit,proto3" json:"bandwidth_limit,omitempty" pg:"bandwidth_limit"`
	CollateralStake      float64  `protobuf:"fixed64,5,opt,name=collateral_stake,json=collateralStake,proto3" json:"collateral_stake,omitempty" pg:"collateral_stake"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SettingsData proto.InternalMessageInfo

func (m *SettingsData) GetStoragePriceAsk() float64 {
	if m != nil {
		return m.StoragePriceAsk
	}
	return 0
}

func (m *SettingsData) GetBandwidthPriceAsk() float64 {
	if m != nil {
		return m.BandwidthPriceAsk
	}
	return 0
}

func (m *SettingsData) GetStorageTimeMin() float64 {
	if m != nil {
		return m.StorageTimeMin
	}
	return 0
}

func (m *SettingsData) GetBandwidthLimit() float64 {
	if m != nil {
		return m.BandwidthLimit
	}
	return 0
}

func (m *SettingsData) GetCollateralStake() float64 {
	if m != nil {
		return m.CollateralStake
	}
	return 0
}

func (*SettingsData) XXX_MessageName() string {
	return "hub.SettingsData"
}

type HostsReq struct {
	Id                   string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" pg:"id"`
	RespSize             int32         `protobuf:"varint,2,opt,name=resp_size,json=respSize,proto3" json:"resp_size,omitempty" pg:"resp_size"`
	Mode                 HostsReq_Mode `protobuf:"varint,3,opt,name=mode,proto3,enum=hub.HostsReq_Mode" json:"mode,omitempty" pg:"mode"`
	Version              string        `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty" pg:"version"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-" pg:"-"`
	XXX_unrecognized     []byte        `json:"-" pg:"-"`
	XXX_sizecache        int32         `json:"-" pg:"-"`
}

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

var xxx_messageInfo_HostsReq proto.InternalMessageInfo

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

func (m *HostsReq) GetRespSize() int32 {
	if m != nil {
		return m.RespSize
	}
	return 0
}

func (m *HostsReq) GetMode() HostsReq_Mode {
	if m != nil {
		return m.Mode
	}
	return HostsReq_SCORE
}

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

func (*HostsReq) XXX_MessageName() string {
	return "hub.HostsReq"
}

type RolesHostsReq struct {
	Id                   string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" pg:"id"`
	RespSize             int32         `protobuf:"varint,2,opt,name=resp_size,json=respSize,proto3" json:"resp_size,omitempty" pg:"resp_size"`
	Role                 node.NodeRole `protobuf:"varint,3,opt,name=role,proto3,enum=node.NodeRole" json:"role,omitempty" pg:"role"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-" pg:"-"`
	XXX_unrecognized     []byte        `json:"-" pg:"-"`
	XXX_sizecache        int32         `json:"-" pg:"-"`
}

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

var xxx_messageInfo_RolesHostsReq proto.InternalMessageInfo

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

func (m *RolesHostsReq) GetRespSize() int32 {
	if m != nil {
		return m.RespSize
	}
	return 0
}

func (m *RolesHostsReq) GetRole() node.NodeRole {
	if m != nil {
		return m.Role
	}
	return node.NodeRole_RENTER
}

func (*RolesHostsReq) XXX_MessageName() string {
	return "hub.RolesHostsReq"
}

type HostsResp struct {
	Code                 ResponseCode `protobuf:"varint,1,opt,name=code,proto3,enum=hub.ResponseCode" json:"code,omitempty" pg:"code"`
	Message              string       `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty" pg:"message"`
	Hosts                *HostsData   `protobuf:"bytes,3,opt,name=hosts,proto3" json:"hosts,omitempty" pg:"hosts"`
	RespSize             int32        `protobuf:"varint,4,opt,name=resp_size,json=respSize,proto3" json:"resp_size,omitempty" pg:"resp_size"`
	Mode                 string       `protobuf:"bytes,5,opt,name=mode,proto3" json:"mode,omitempty" pg:"mode"`
	ResponseTime         time.Time    `protobuf:"bytes,6,opt,name=response_time,json=responseTime,proto3,stdtime" json:"response_time" pg:"response_time"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-" pg:"-"`
	XXX_unrecognized     []byte       `json:"-" pg:"-"`
	XXX_sizecache        int32        `json:"-" pg:"-"`
}

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

var xxx_messageInfo_HostsResp proto.InternalMessageInfo

func (m *HostsResp) GetCode() ResponseCode {
	if m != nil {
		return m.Code
	}
	return ResponseCode_SUCCESS
}

func (m *HostsResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *HostsResp) GetHosts() *HostsData {
	if m != nil {
		return m.Hosts
	}
	return nil
}

func (m *HostsResp) GetRespSize() int32 {
	if m != nil {
		return m.RespSize
	}
	return 0
}

func (m *HostsResp) GetMode() string {
	if m != nil {
		return m.Mode
	}
	return ""
}

func (m *HostsResp) GetResponseTime() time.Time {
	if m != nil {
		return m.ResponseTime
	}
	return time.Time{}
}

func (*HostsResp) XXX_MessageName() string {
	return "hub.HostsResp"
}

type StatsReq struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" pg:"id"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StatsReq proto.InternalMessageInfo

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

func (*StatsReq) XXX_MessageName() string {
	return "hub.StatsReq"
}

type StatsResp struct {
	Code                       ResponseCode `protobuf:"varint,1,opt,name=code,proto3,enum=hub.ResponseCode" json:"code,omitempty" pg:"code"`
	Message                    string       `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty" pg:"message"`
	ResponseTime               time.Time    `protobuf:"bytes,3,opt,name=response_time,json=responseTime,proto3,stdtime" json:"response_time" pg:"response_time"`
	node.StorageStat_HostStats `protobuf:"bytes,4,opt,name=stats,proto3,embedded=stats" json:"stats" pg:"stats"`
	XXX_NoUnkeyedLiteral       struct{} `json:"-" pg:"-"`
	XXX_unrecognized           []byte   `json:"-" pg:"-"`
	XXX_sizecache              int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StatsResp proto.InternalMessageInfo

func (m *StatsResp) GetCode() ResponseCode {
	if m != nil {
		return m.Code
	}
	return ResponseCode_SUCCESS
}

func (m *StatsResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *StatsResp) GetResponseTime() time.Time {
	if m != nil {
		return m.ResponseTime
	}
	return time.Time{}
}

func (*StatsResp) XXX_MessageName() string {
	return "hub.StatsResp"
}

type Candidate struct {
	NodeId               string   `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty" pg:"node_id"`
	HeartBeats           uint64   `protobuf:"varint,2,opt,name=heart_beats,json=heartBeats,proto3" json:"heart_beats,omitempty" pg:"heart_beats"`
	UploadAverage        float32  `protobuf:"fixed32,3,opt,name=upload_average,json=uploadAverage,proto3" json:"upload_average,omitempty" pg:"upload_average"`
	UploadVariance       float32  `protobuf:"fixed32,4,opt,name=upload_variance,json=uploadVariance,proto3" json:"upload_variance,omitempty" pg:"upload_variance"`
	DownloadAverage      float32  `protobuf:"fixed32,5,opt,name=download_average,json=downloadAverage,proto3" json:"download_average,omitempty" pg:"download_average"`
	DownloadVariance     float32  `protobuf:"fixed32,6,opt,name=download_variance,json=downloadVariance,proto3" json:"download_variance,omitempty" pg:"download_variance"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Candidate proto.InternalMessageInfo

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

func (m *Candidate) GetHeartBeats() uint64 {
	if m != nil {
		return m.HeartBeats
	}
	return 0
}

func (m *Candidate) GetUploadAverage() float32 {
	if m != nil {
		return m.UploadAverage
	}
	return 0
}

func (m *Candidate) GetUploadVariance() float32 {
	if m != nil {
		return m.UploadVariance
	}
	return 0
}

func (m *Candidate) GetDownloadAverage() float32 {
	if m != nil {
		return m.DownloadAverage
	}
	return 0
}

func (m *Candidate) GetDownloadVariance() float32 {
	if m != nil {
		return m.DownloadVariance
	}
	return 0
}

func (*Candidate) XXX_MessageName() string {
	return "hub.Candidate"
}

type ParseReq struct {
	Candidates           []*Candidate `protobuf:"bytes,1,rep,name=candidates,proto3" json:"candidates,omitempty" pg:"candidates"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-" pg:"-"`
	XXX_unrecognized     []byte       `json:"-" pg:"-"`
	XXX_sizecache        int32        `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ParseReq proto.InternalMessageInfo

func (m *ParseReq) GetCandidates() []*Candidate {
	if m != nil {
		return m.Candidates
	}
	return nil
}

func (*ParseReq) XXX_MessageName() string {
	return "hub.ParseReq"
}

type RecycleReq struct {
	EsIndex              RecycleReq_ESIndex `protobuf:"varint,1,opt,name=es_index,json=esIndex,proto3,enum=hub.RecycleReq_ESIndex" json:"es_index,omitempty" pg:"es_index"`
	TimeScopeInHours     int64              `protobuf:"varint,2,opt,name=time_scope_in_hours,json=timeScopeInHours,proto3" json:"time_scope_in_hours,omitempty" pg:"time_scope_in_hours"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-" pg:"-"`
	XXX_unrecognized     []byte             `json:"-" pg:"-"`
	XXX_sizecache        int32              `json:"-" pg:"-"`
}

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

var xxx_messageInfo_RecycleReq proto.InternalMessageInfo

func (m *RecycleReq) GetEsIndex() RecycleReq_ESIndex {
	if m != nil {
		return m.EsIndex
	}
	return RecycleReq_NODES
}

func (m *RecycleReq) GetTimeScopeInHours() int64 {
	if m != nil {
		return m.TimeScopeInHours
	}
	return 0
}

func (*RecycleReq) XXX_MessageName() string {
	return "hub.RecycleReq"
}

type ParseResp struct {
	Code                 ResponseCode `protobuf:"varint,1,opt,name=code,proto3,enum=hub.ResponseCode" json:"code,omitempty" pg:"code"`
	Message              string       `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty" pg:"message"`
	ResponseTime         time.Time    `protobuf:"bytes,3,opt,name=response_time,json=responseTime,proto3,stdtime" json:"response_time" pg:"response_time"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-" pg:"-"`
	XXX_unrecognized     []byte       `json:"-" pg:"-"`
	XXX_sizecache        int32        `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ParseResp proto.InternalMessageInfo

func (m *ParseResp) GetCode() ResponseCode {
	if m != nil {
		return m.Code
	}
	return ResponseCode_SUCCESS
}

func (m *ParseResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *ParseResp) GetResponseTime() time.Time {
	if m != nil {
		return m.ResponseTime
	}
	return time.Time{}
}

func (*ParseResp) XXX_MessageName() string {
	return "hub.ParseResp"
}

type HostsData struct {
	Hosts                []*Host  `protobuf:"bytes,1,rep,name=hosts,proto3" json:"hosts,omitempty" pg:"hosts"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_HostsData proto.InternalMessageInfo

func (m *HostsData) GetHosts() []*Host {
	if m != nil {
		return m.Hosts
	}
	return nil
}

func (*HostsData) XXX_MessageName() string {
	return "hub.HostsData"
}

type Host struct {
	NodeId                      string    `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id" pg:"node_id"`
	CreateTimestamp             time.Time `protobuf:"bytes,2,opt,name=create_timestamp,json=createTimestamp,proto3,stdtime" json:"create_timestamp" pg:"create_timestamp"`
	UpdateTimestamp             time.Time `protobuf:"bytes,3,opt,name=update_timestamp,json=updateTimestamp,proto3,stdtime" json:"update_timestamp" pg:"update_timestamp"`
	Region                      string    `protobuf:"bytes,4,opt,name=region,proto3" json:"region" pg:"region"`
	BtfsVersion                 string    `protobuf:"bytes,5,opt,name=btfs_version,json=btfsVersion,proto3" json:"btfs_version" pg:"btfs_version"`
	Score                       float32   `protobuf:"fixed32,6,opt,name=score,proto3" json:"score" pg:"score"`
	HeartBeats                  uint64    `protobuf:"varint,7,opt,name=heart_beats,json=heartBeats,proto3" json:"heart_beats" pg:"heart_beats"`
	Uptime                      float32   `protobuf:"fixed32,8,opt,name=uptime,proto3" json:"uptime" pg:"uptime"`
	Age                         uint64    `protobuf:"varint,9,opt,name=age,proto3" json:"age" pg:"age"`
	Reputation                  float32   `protobuf:"fixed32,10,opt,name=reputation,proto3" json:"reputation" pg:"reputation"`
	UploadAverage               float32   `protobuf:"fixed32,11,opt,name=upload_average,json=uploadAverage,proto3" json:"upload_average" pg:"upload_average"`
	UploadVariance              float32   `protobuf:"fixed32,12,opt,name=upload_variance,json=uploadVariance,proto3" json:"upload_variance" pg:"upload_variance"`
	DownloadAverage             float32   `protobuf:"fixed32,13,opt,name=download_average,json=downloadAverage,proto3" json:"download_average" pg:"download_average"`
	DownloadVariance            float32   `protobuf:"fixed32,14,opt,name=download_variance,json=downloadVariance,proto3" json:"download_variance" pg:"download_variance"`
	Location                    Location  `protobuf:"bytes,15,opt,name=location,proto3" json:"location" pg:"location"`
	StorageVolumeCap            float32   `protobuf:"fixed32,16,opt,name=storage_volume_cap,json=storageVolumeCap,proto3" json:"storage_volume_cap" pg:"storage_volume_cap"`
	StorageVolumeLeft           float32   `protobuf:"fixed32,17,opt,name=storage_volume_left,json=storageVolumeLeft,proto3" json:"storage_volume_left" pg:"storage_volume_left"`
	StorageTimeMin              uint64    `protobuf:"varint,18,opt,name=storage_time_min,json=storageTimeMin,proto3" json:"storage_time_min" pg:"storage_time_min"`
	StoragePriceAsk             uint64    `protobuf:"varint,19,opt,name=storage_price_ask,json=storagePriceAsk,proto3" json:"storage_price_ask" pg:"storage_price_ask"`
	StoragePriceEst             uint64    `protobuf:"varint,20,opt,name=storage_price_est,json=storagePriceEst,proto3" json:"storage_price_est" pg:"storage_price_est"`
	BandwidthLimit              float64   `protobuf:"fixed64,21,opt,name=bandwidth_limit,json=bandwidthLimit,proto3" json:"bandwidth_limit" pg:"bandwidth_limit"`
	BandwidthPriceAsk           uint64    `protobuf:"varint,22,opt,name=bandwidth_price_ask,json=bandwidthPriceAsk,proto3" json:"bandwidth_price_ask" pg:"bandwidth_price_ask"`
	BandwidthPriceEst           uint64    `protobuf:"varint,23,opt,name=bandwidth_price_est,json=bandwidthPriceEst,proto3" json:"bandwidth_price_est" pg:"bandwidth_price_est"`
	CollateralStake             uint64    `protobuf:"varint,24,opt,name=collateral_stake,json=collateralStake,proto3" json:"collateral_stake" pg:"collateral_stake"`
	CollateralLost              uint64    `protobuf:"varint,25,opt,name=collateral_lost,json=collateralLost,proto3" json:"collateral_lost" pg:"collateral_lost"`
	CollateralBurn              uint64    `protobuf:"varint,26,opt,name=collateral_burn,json=collateralBurn,proto3" json:"collateral_burn" pg:"collateral_burn"`
	CountryShort                string    `protobuf:"bytes,27,opt,name=country_short,json=countryShort,proto3" json:"country_short" pg:"country_short"`
	node.Node_ExperimentalFlags `protobuf:"bytes,28,opt,name=flg,proto3,embedded=flg" json:"flg" pg:"flg"`
	Discovery                   float32         `protobuf:"fixed32,29,opt,name=discovery,proto3" json:"discovery" pg:"discovery"`
	UptimeScore                 float32         `protobuf:"fixed32,30,opt,name=uptime_score,json=uptimeScore,proto3" json:"uptime_score" pg:"uptime_score"`
	AgeScore                    float32         `protobuf:"fixed32,31,opt,name=age_score,json=ageScore,proto3" json:"age_score" pg:"age_score"`
	VersionScore                float32         `protobuf:"fixed32,32,opt,name=version_score,json=versionScore,proto3" json:"version_score" pg:"version_score"`
	UploadSpeedScore            float32         `protobuf:"fixed32,33,opt,name=upload_speed_score,json=uploadSpeedScore,proto3" json:"upload_speed_score" pg:"upload_speed_score"`
	DownloadSpeedScore          float32         `protobuf:"fixed32,34,opt,name=download_speed_score,json=downloadSpeedScore,proto3" json:"download_speed_score" pg:"download_speed_score"`
	Roles                       []node.NodeRole `protobuf:"varint,35,rep,packed,name=roles,proto3,enum=node.NodeRole" json:"roles" pg:"roles,array"`
	XXX_NoUnkeyedLiteral        struct{}        `json:"-" pg:"-"`
	XXX_unrecognized            []byte          `json:"-" pg:"-"`
	XXX_sizecache               int32           `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Host proto.InternalMessageInfo

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

func (m *Host) GetCreateTimestamp() time.Time {
	if m != nil {
		return m.CreateTimestamp
	}
	return time.Time{}
}

func (m *Host) GetUpdateTimestamp() time.Time {
	if m != nil {
		return m.UpdateTimestamp
	}
	return time.Time{}
}

func (m *Host) GetRegion() string {
	if m != nil {
		return m.Region
	}
	return ""
}

func (m *Host) GetBtfsVersion() string {
	if m != nil {
		return m.BtfsVersion
	}
	return ""
}

func (m *Host) GetScore() float32 {
	if m != nil {
		return m.Score
	}
	return 0
}

func (m *Host) GetHeartBeats() uint64 {
	if m != nil {
		return m.HeartBeats
	}
	return 0
}

func (m *Host) GetUptime() float32 {
	if m != nil {
		return m.Uptime
	}
	return 0
}

func (m *Host) GetAge() uint64 {
	if m != nil {
		return m.Age
	}
	return 0
}

func (m *Host) GetReputation() float32 {
	if m != nil {
		return m.Reputation
	}
	return 0
}

func (m *Host) GetUploadAverage() float32 {
	if m != nil {
		return m.UploadAverage
	}
	return 0
}

func (m *Host) GetUploadVariance() float32 {
	if m != nil {
		return m.UploadVariance
	}
	return 0
}

func (m *Host) GetDownloadAverage() float32 {
	if m != nil {
		return m.DownloadAverage
	}
	return 0
}

func (m *Host) GetDownloadVariance() float32 {
	if m != nil {
		return m.DownloadVariance
	}
	return 0
}

func (m *Host) GetLocation() Location {
	if m != nil {
		return m.Location
	}
	return Location{}
}

func (m *Host) GetStorageVolumeCap() float32 {
	if m != nil {
		return m.StorageVolumeCap
	}
	return 0
}

func (m *Host) GetStorageVolumeLeft() float32 {
	if m != nil {
		return m.StorageVolumeLeft
	}
	return 0
}

func (m *Host) GetStorageTimeMin() uint64 {
	if m != nil {
		return m.StorageTimeMin
	}
	return 0
}

func (m *Host) GetStoragePriceAsk() uint64 {
	if m != nil {
		return m.StoragePriceAsk
	}
	return 0
}

func (m *Host) GetStoragePriceEst() uint64 {
	if m != nil {
		return m.StoragePriceEst
	}
	return 0
}

func (m *Host) GetBandwidthLimit() float64 {
	if m != nil {
		return m.BandwidthLimit
	}
	return 0
}

func (m *Host) GetBandwidthPriceAsk() uint64 {
	if m != nil {
		return m.BandwidthPriceAsk
	}
	return 0
}

func (m *Host) GetBandwidthPriceEst() uint64 {
	if m != nil {
		return m.BandwidthPriceEst
	}
	return 0
}

func (m *Host) GetCollateralStake() uint64 {
	if m != nil {
		return m.CollateralStake
	}
	return 0
}

func (m *Host) GetCollateralLost() uint64 {
	if m != nil {
		return m.CollateralLost
	}
	return 0
}

func (m *Host) GetCollateralBurn() uint64 {
	if m != nil {
		return m.CollateralBurn
	}
	return 0
}

func (m *Host) GetCountryShort() string {
	if m != nil {
		return m.CountryShort
	}
	return ""
}

func (m *Host) GetDiscovery() float32 {
	if m != nil {
		return m.Discovery
	}
	return 0
}

func (m *Host) GetUptimeScore() float32 {
	if m != nil {
		return m.UptimeScore
	}
	return 0
}

func (m *Host) GetAgeScore() float32 {
	if m != nil {
		return m.AgeScore
	}
	return 0
}

func (m *Host) GetVersionScore() float32 {
	if m != nil {
		return m.VersionScore
	}
	return 0
}

func (m *Host) GetUploadSpeedScore() float32 {
	if m != nil {
		return m.UploadSpeedScore
	}
	return 0
}

func (m *Host) GetDownloadSpeedScore() float32 {
	if m != nil {
		return m.DownloadSpeedScore
	}
	return 0
}

func (m *Host) GetRoles() []node.NodeRole {
	if m != nil {
		return m.Roles
	}
	return nil
}

func (*Host) XXX_MessageName() string {
	return "hub.Host"
}

type Location struct {
	Lat                  float64  `protobuf:"fixed64,1,opt,name=lat,proto3" json:"lat,omitempty" pg:"lat"`
	Lon                  float64  `protobuf:"fixed64,2,opt,name=lon,proto3" json:"lon,omitempty" pg:"lon"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Location proto.InternalMessageInfo

func (m *Location) GetLat() float64 {
	if m != nil {
		return m.Lat
	}
	return 0
}

func (m *Location) GetLon() float64 {
	if m != nil {
		return m.Lon
	}
	return 0
}

func (*Location) XXX_MessageName() string {
	return "hub.Location"
}
func init() {
	proto.RegisterEnum("hub.ResponseCode", ResponseCode_name, ResponseCode_value)
	golang_proto.RegisterEnum("hub.ResponseCode", ResponseCode_name, ResponseCode_value)
	proto.RegisterEnum("hub.HostsReq_Mode", HostsReq_Mode_name, HostsReq_Mode_value)
	golang_proto.RegisterEnum("hub.HostsReq_Mode", HostsReq_Mode_name, HostsReq_Mode_value)
	proto.RegisterEnum("hub.RecycleReq_ESIndex", RecycleReq_ESIndex_name, RecycleReq_ESIndex_value)
	golang_proto.RegisterEnum("hub.RecycleReq_ESIndex", RecycleReq_ESIndex_name, RecycleReq_ESIndex_value)
	proto.RegisterType((*NodesReq)(nil), "hub.NodesReq")
	golang_proto.RegisterType((*NodesReq)(nil), "hub.NodesReq")
	proto.RegisterType((*SettingsReq)(nil), "hub.SettingsReq")
	golang_proto.RegisterType((*SettingsReq)(nil), "hub.SettingsReq")
	proto.RegisterType((*SettingsResp)(nil), "hub.SettingsResp")
	golang_proto.RegisterType((*SettingsResp)(nil), "hub.SettingsResp")
	proto.RegisterType((*SettingsData)(nil), "hub.SettingsData")
	golang_proto.RegisterType((*SettingsData)(nil), "hub.SettingsData")
	proto.RegisterType((*HostsReq)(nil), "hub.HostsReq")
	golang_proto.RegisterType((*HostsReq)(nil), "hub.HostsReq")
	proto.RegisterType((*RolesHostsReq)(nil), "hub.RolesHostsReq")
	golang_proto.RegisterType((*RolesHostsReq)(nil), "hub.RolesHostsReq")
	proto.RegisterType((*HostsResp)(nil), "hub.HostsResp")
	golang_proto.RegisterType((*HostsResp)(nil), "hub.HostsResp")
	proto.RegisterType((*StatsReq)(nil), "hub.StatsReq")
	golang_proto.RegisterType((*StatsReq)(nil), "hub.StatsReq")
	proto.RegisterType((*StatsResp)(nil), "hub.StatsResp")
	golang_proto.RegisterType((*StatsResp)(nil), "hub.StatsResp")
	proto.RegisterType((*Candidate)(nil), "hub.Candidate")
	golang_proto.RegisterType((*Candidate)(nil), "hub.Candidate")
	proto.RegisterType((*ParseReq)(nil), "hub.ParseReq")
	golang_proto.RegisterType((*ParseReq)(nil), "hub.ParseReq")
	proto.RegisterType((*RecycleReq)(nil), "hub.RecycleReq")
	golang_proto.RegisterType((*RecycleReq)(nil), "hub.RecycleReq")
	proto.RegisterType((*ParseResp)(nil), "hub.ParseResp")
	golang_proto.RegisterType((*ParseResp)(nil), "hub.ParseResp")
	proto.RegisterType((*HostsData)(nil), "hub.HostsData")
	golang_proto.RegisterType((*HostsData)(nil), "hub.HostsData")
	proto.RegisterType((*Host)(nil), "hub.Host")
	golang_proto.RegisterType((*Host)(nil), "hub.Host")
	proto.RegisterType((*Location)(nil), "hub.Location")
	golang_proto.RegisterType((*Location)(nil), "hub.Location")
}

func init() { proto.RegisterFile("protos/hub/hub.proto", fileDescriptor_c704b5990190a69f) }
func init() { golang_proto.RegisterFile("protos/hub/hub.proto", fileDescriptor_c704b5990190a69f) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// HubQueryServiceClient is the client API for HubQueryService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type HubQueryServiceClient interface {
	GetSettings(ctx context.Context, in *SettingsReq, opts ...grpc.CallOption) (*SettingsResp, error)
	GetHosts(ctx context.Context, in *HostsReq, opts ...grpc.CallOption) (*HostsResp, error)
	GetStats(ctx context.Context, in *StatsReq, opts ...grpc.CallOption) (*StatsResp, error)
	QueryNodes(ctx context.Context, in *NodesReq, opts ...grpc.CallOption) (*HostsResp, error)
	GetHostsByRoles(ctx context.Context, in *RolesHostsReq, opts ...grpc.CallOption) (*HostsResp, error)
}

type hubQueryServiceClient struct {
	cc *grpc.ClientConn
}

func NewHubQueryServiceClient(cc *grpc.ClientConn) HubQueryServiceClient {
	return &hubQueryServiceClient{cc}
}

func (c *hubQueryServiceClient) GetSettings(ctx context.Context, in *SettingsReq, opts ...grpc.CallOption) (*SettingsResp, error) {
	out := new(SettingsResp)
	err := c.cc.Invoke(ctx, "/hub.HubQueryService/GetSettings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hubQueryServiceClient) GetHosts(ctx context.Context, in *HostsReq, opts ...grpc.CallOption) (*HostsResp, error) {
	out := new(HostsResp)
	err := c.cc.Invoke(ctx, "/hub.HubQueryService/GetHosts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hubQueryServiceClient) GetStats(ctx context.Context, in *StatsReq, opts ...grpc.CallOption) (*StatsResp, error) {
	out := new(StatsResp)
	err := c.cc.Invoke(ctx, "/hub.HubQueryService/GetStats", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hubQueryServiceClient) QueryNodes(ctx context.Context, in *NodesReq, opts ...grpc.CallOption) (*HostsResp, error) {
	out := new(HostsResp)
	err := c.cc.Invoke(ctx, "/hub.HubQueryService/QueryNodes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hubQueryServiceClient) GetHostsByRoles(ctx context.Context, in *RolesHostsReq, opts ...grpc.CallOption) (*HostsResp, error) {
	out := new(HostsResp)
	err := c.cc.Invoke(ctx, "/hub.HubQueryService/GetHostsByRoles", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// HubQueryServiceServer is the server API for HubQueryService service.
type HubQueryServiceServer interface {
	GetSettings(context.Context, *SettingsReq) (*SettingsResp, error)
	GetHosts(context.Context, *HostsReq) (*HostsResp, error)
	GetStats(context.Context, *StatsReq) (*StatsResp, error)
	QueryNodes(context.Context, *NodesReq) (*HostsResp, error)
	GetHostsByRoles(context.Context, *RolesHostsReq) (*HostsResp, error)
}

// UnimplementedHubQueryServiceServer can be embedded to have forward compatible implementations.
type UnimplementedHubQueryServiceServer struct {
}

func (*UnimplementedHubQueryServiceServer) GetSettings(ctx context.Context, req *SettingsReq) (*SettingsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSettings not implemented")
}
func (*UnimplementedHubQueryServiceServer) GetHosts(ctx context.Context, req *HostsReq) (*HostsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHosts not implemented")
}
func (*UnimplementedHubQueryServiceServer) GetStats(ctx context.Context, req *StatsReq) (*StatsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStats not implemented")
}
func (*UnimplementedHubQueryServiceServer) QueryNodes(ctx context.Context, req *NodesReq) (*HostsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryNodes not implemented")
}
func (*UnimplementedHubQueryServiceServer) GetHostsByRoles(ctx context.Context, req *RolesHostsReq) (*HostsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHostsByRoles not implemented")
}

func RegisterHubQueryServiceServer(s *grpc.Server, srv HubQueryServiceServer) {
	s.RegisterService(&_HubQueryService_serviceDesc, srv)
}

func _HubQueryService_GetSettings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SettingsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HubQueryServiceServer).GetSettings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hub.HubQueryService/GetSettings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HubQueryServiceServer).GetSettings(ctx, req.(*SettingsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _HubQueryService_GetHosts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HostsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HubQueryServiceServer).GetHosts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hub.HubQueryService/GetHosts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HubQueryServiceServer).GetHosts(ctx, req.(*HostsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _HubQueryService_GetStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HubQueryServiceServer).GetStats(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hub.HubQueryService/GetStats",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HubQueryServiceServer).GetStats(ctx, req.(*StatsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _HubQueryService_QueryNodes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NodesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HubQueryServiceServer).QueryNodes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hub.HubQueryService/QueryNodes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HubQueryServiceServer).QueryNodes(ctx, req.(*NodesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _HubQueryService_GetHostsByRoles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RolesHostsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HubQueryServiceServer).GetHostsByRoles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hub.HubQueryService/GetHostsByRoles",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HubQueryServiceServer).GetHostsByRoles(ctx, req.(*RolesHostsReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _HubQueryService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "hub.HubQueryService",
	HandlerType: (*HubQueryServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetSettings",
			Handler:    _HubQueryService_GetSettings_Handler,
		},
		{
			MethodName: "GetHosts",
			Handler:    _HubQueryService_GetHosts_Handler,
		},
		{
			MethodName: "GetStats",
			Handler:    _HubQueryService_GetStats_Handler,
		},
		{
			MethodName: "QueryNodes",
			Handler:    _HubQueryService_QueryNodes_Handler,
		},
		{
			MethodName: "GetHostsByRoles",
			Handler:    _HubQueryService_GetHostsByRoles_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "protos/hub/hub.proto",
}

// HubParseServiceClient is the client API for HubParseService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type HubParseServiceClient interface {
	UpdateDiscovery(ctx context.Context, in *ParseReq, opts ...grpc.CallOption) (*ParseResp, error)
	UpdateScore(ctx context.Context, in *ParseReq, opts ...grpc.CallOption) (*ParseResp, error)
	UpdateNetwork(ctx context.Context, in *ParseReq, opts ...grpc.CallOption) (*ParseResp, error)
	Recycle(ctx context.Context, in *RecycleReq, opts ...grpc.CallOption) (*ParseResp, error)
	UpdateBtfsScan(ctx context.Context, in *ParseReq, opts ...grpc.CallOption) (*ParseResp, error)
	UpdateScoreHistory(ctx context.Context, in *ParseReq, opts ...grpc.CallOption) (*ParseResp, error)
}

type hubParseServiceClient struct {
	cc *grpc.ClientConn
}

func NewHubParseServiceClient(cc *grpc.ClientConn) HubParseServiceClient {
	return &hubParseServiceClient{cc}
}

func (c *hubParseServiceClient) UpdateDiscovery(ctx context.Context, in *ParseReq, opts ...grpc.CallOption) (*ParseResp, error) {
	out := new(ParseResp)
	err := c.cc.Invoke(ctx, "/hub.HubParseService/UpdateDiscovery", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hubParseServiceClient) UpdateScore(ctx context.Context, in *ParseReq, opts ...grpc.CallOption) (*ParseResp, error) {
	out := new(ParseResp)
	err := c.cc.Invoke(ctx, "/hub.HubParseService/UpdateScore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hubParseServiceClient) UpdateNetwork(ctx context.Context, in *ParseReq, opts ...grpc.CallOption) (*ParseResp, error) {
	out := new(ParseResp)
	err := c.cc.Invoke(ctx, "/hub.HubParseService/UpdateNetwork", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hubParseServiceClient) Recycle(ctx context.Context, in *RecycleReq, opts ...grpc.CallOption) (*ParseResp, error) {
	out := new(ParseResp)
	err := c.cc.Invoke(ctx, "/hub.HubParseService/Recycle", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hubParseServiceClient) UpdateBtfsScan(ctx context.Context, in *ParseReq, opts ...grpc.CallOption) (*ParseResp, error) {
	out := new(ParseResp)
	err := c.cc.Invoke(ctx, "/hub.HubParseService/UpdateBtfsScan", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hubParseServiceClient) UpdateScoreHistory(ctx context.Context, in *ParseReq, opts ...grpc.CallOption) (*ParseResp, error) {
	out := new(ParseResp)
	err := c.cc.Invoke(ctx, "/hub.HubParseService/UpdateScoreHistory", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// HubParseServiceServer is the server API for HubParseService service.
type HubParseServiceServer interface {
	UpdateDiscovery(context.Context, *ParseReq) (*ParseResp, error)
	UpdateScore(context.Context, *ParseReq) (*ParseResp, error)
	UpdateNetwork(context.Context, *ParseReq) (*ParseResp, error)
	Recycle(context.Context, *RecycleReq) (*ParseResp, error)
	UpdateBtfsScan(context.Context, *ParseReq) (*ParseResp, error)
	UpdateScoreHistory(context.Context, *ParseReq) (*ParseResp, error)
}

// UnimplementedHubParseServiceServer can be embedded to have forward compatible implementations.
type UnimplementedHubParseServiceServer struct {
}

func (*UnimplementedHubParseServiceServer) UpdateDiscovery(ctx context.Context, req *ParseReq) (*ParseResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateDiscovery not implemented")
}
func (*UnimplementedHubParseServiceServer) UpdateScore(ctx context.Context, req *ParseReq) (*ParseResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateScore not implemented")
}
func (*UnimplementedHubParseServiceServer) UpdateNetwork(ctx context.Context, req *ParseReq) (*ParseResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateNetwork not implemented")
}
func (*UnimplementedHubParseServiceServer) Recycle(ctx context.Context, req *RecycleReq) (*ParseResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Recycle not implemented")
}
func (*UnimplementedHubParseServiceServer) UpdateBtfsScan(ctx context.Context, req *ParseReq) (*ParseResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateBtfsScan not implemented")
}
func (*UnimplementedHubParseServiceServer) UpdateScoreHistory(ctx context.Context, req *ParseReq) (*ParseResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateScoreHistory not implemented")
}

func RegisterHubParseServiceServer(s *grpc.Server, srv HubParseServiceServer) {
	s.RegisterService(&_HubParseService_serviceDesc, srv)
}

func _HubParseService_UpdateDiscovery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParseReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HubParseServiceServer).UpdateDiscovery(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hub.HubParseService/UpdateDiscovery",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HubParseServiceServer).UpdateDiscovery(ctx, req.(*ParseReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _HubParseService_UpdateScore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParseReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HubParseServiceServer).UpdateScore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hub.HubParseService/UpdateScore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HubParseServiceServer).UpdateScore(ctx, req.(*ParseReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _HubParseService_UpdateNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParseReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HubParseServiceServer).UpdateNetwork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hub.HubParseService/UpdateNetwork",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HubParseServiceServer).UpdateNetwork(ctx, req.(*ParseReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _HubParseService_Recycle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RecycleReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HubParseServiceServer).Recycle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hub.HubParseService/Recycle",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HubParseServiceServer).Recycle(ctx, req.(*RecycleReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _HubParseService_UpdateBtfsScan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParseReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HubParseServiceServer).UpdateBtfsScan(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hub.HubParseService/UpdateBtfsScan",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HubParseServiceServer).UpdateBtfsScan(ctx, req.(*ParseReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _HubParseService_UpdateScoreHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParseReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HubParseServiceServer).UpdateScoreHistory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hub.HubParseService/UpdateScoreHistory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HubParseServiceServer).UpdateScoreHistory(ctx, req.(*ParseReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _HubParseService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "hub.HubParseService",
	HandlerType: (*HubParseServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "UpdateDiscovery",
			Handler:    _HubParseService_UpdateDiscovery_Handler,
		},
		{
			MethodName: "UpdateScore",
			Handler:    _HubParseService_UpdateScore_Handler,
		},
		{
			MethodName: "UpdateNetwork",
			Handler:    _HubParseService_UpdateNetwork_Handler,
		},
		{
			MethodName: "Recycle",
			Handler:    _HubParseService_Recycle_Handler,
		},
		{
			MethodName: "UpdateBtfsScan",
			Handler:    _HubParseService_UpdateBtfsScan_Handler,
		},
		{
			MethodName: "UpdateScoreHistory",
			Handler:    _HubParseService_UpdateScoreHistory_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "protos/hub/hub.proto",
}

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

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

func (m *NodesReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.RequesterId) > 0 {
		i -= len(m.RequesterId)
		copy(dAtA[i:], m.RequesterId)
		i = encodeVarintHub(dAtA, i, uint64(len(m.RequesterId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.NodeId) > 0 {
		for iNdEx := len(m.NodeId) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.NodeId[iNdEx])
			copy(dAtA[i:], m.NodeId[iNdEx])
			i = encodeVarintHub(dAtA, i, uint64(len(m.NodeId[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SettingsReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.RespSize != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.RespSize))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SettingsResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.SettingsData != nil {
		{
			size, err := m.SettingsData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	n2, err2 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.ResponseTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.ResponseTime):])
	if err2 != nil {
		return 0, err2
	}
	i -= n2
	i = encodeVarintHub(dAtA, i, uint64(n2))
	i--
	dAtA[i] = 0x1a
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SettingsData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.CollateralStake != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.CollateralStake))))
		i--
		dAtA[i] = 0x29
	}
	if m.BandwidthLimit != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.BandwidthLimit))))
		i--
		dAtA[i] = 0x21
	}
	if m.StorageTimeMin != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.StorageTimeMin))))
		i--
		dAtA[i] = 0x19
	}
	if m.BandwidthPriceAsk != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.BandwidthPriceAsk))))
		i--
		dAtA[i] = 0x11
	}
	if m.StoragePriceAsk != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.StoragePriceAsk))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

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

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

func (m *HostsReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x22
	}
	if m.Mode != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x18
	}
	if m.RespSize != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.RespSize))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *RolesHostsReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Role != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.Role))
		i--
		dAtA[i] = 0x18
	}
	if m.RespSize != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.RespSize))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *HostsResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	n3, err3 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.ResponseTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.ResponseTime):])
	if err3 != nil {
		return 0, err3
	}
	i -= n3
	i = encodeVarintHub(dAtA, i, uint64(n3))
	i--
	dAtA[i] = 0x32
	if len(m.Mode) > 0 {
		i -= len(m.Mode)
		copy(dAtA[i:], m.Mode)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Mode)))
		i--
		dAtA[i] = 0x2a
	}
	if m.RespSize != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.RespSize))
		i--
		dAtA[i] = 0x20
	}
	if m.Hosts != nil {
		{
			size, err := m.Hosts.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *StatsReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *StatsResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.StorageStat_HostStats.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintHub(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	n6, err6 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.ResponseTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.ResponseTime):])
	if err6 != nil {
		return 0, err6
	}
	i -= n6
	i = encodeVarintHub(dAtA, i, uint64(n6))
	i--
	dAtA[i] = 0x1a
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Candidate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.DownloadVariance != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.DownloadVariance))))
		i--
		dAtA[i] = 0x35
	}
	if m.DownloadAverage != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.DownloadAverage))))
		i--
		dAtA[i] = 0x2d
	}
	if m.UploadVariance != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UploadVariance))))
		i--
		dAtA[i] = 0x25
	}
	if m.UploadAverage != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UploadAverage))))
		i--
		dAtA[i] = 0x1d
	}
	if m.HeartBeats != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.HeartBeats))
		i--
		dAtA[i] = 0x10
	}
	if len(m.NodeId) > 0 {
		i -= len(m.NodeId)
		copy(dAtA[i:], m.NodeId)
		i = encodeVarintHub(dAtA, i, uint64(len(m.NodeId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *RecycleReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.TimeScopeInHours != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.TimeScopeInHours))
		i--
		dAtA[i] = 0x10
	}
	if m.EsIndex != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.EsIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ParseResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	n7, err7 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.ResponseTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.ResponseTime):])
	if err7 != nil {
		return 0, err7
	}
	i -= n7
	i = encodeVarintHub(dAtA, i, uint64(n7))
	i--
	dAtA[i] = 0x1a
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *Host) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Roles) > 0 {
		dAtA9 := make([]byte, len(m.Roles)*10)
		var j8 int
		for _, num := range m.Roles {
			for num >= 1<<7 {
				dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j8++
			}
			dAtA9[j8] = uint8(num)
			j8++
		}
		i -= j8
		copy(dAtA[i:], dAtA9[:j8])
		i = encodeVarintHub(dAtA, i, uint64(j8))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x9a
	}
	if m.DownloadSpeedScore != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.DownloadSpeedScore))))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x95
	}
	if m.UploadSpeedScore != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UploadSpeedScore))))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x8d
	}
	if m.VersionScore != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.VersionScore))))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x85
	}
	if m.AgeScore != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.AgeScore))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xfd
	}
	if m.UptimeScore != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UptimeScore))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf5
	}
	if m.Discovery != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Discovery))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xed
	}
	{
		size, err := m.Node_ExperimentalFlags.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintHub(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xe2
	if len(m.CountryShort) > 0 {
		i -= len(m.CountryShort)
		copy(dAtA[i:], m.CountryShort)
		i = encodeVarintHub(dAtA, i, uint64(len(m.CountryShort)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xda
	}
	if m.CollateralBurn != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.CollateralBurn))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd0
	}
	if m.CollateralLost != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.CollateralLost))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc8
	}
	if m.CollateralStake != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.CollateralStake))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc0
	}
	if m.BandwidthPriceEst != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.BandwidthPriceEst))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb8
	}
	if m.BandwidthPriceAsk != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.BandwidthPriceAsk))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb0
	}
	if m.BandwidthLimit != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.BandwidthLimit))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa9
	}
	if m.StoragePriceEst != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.StoragePriceEst))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa0
	}
	if m.StoragePriceAsk != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.StoragePriceAsk))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	if m.StorageTimeMin != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.StorageTimeMin))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	if m.StorageVolumeLeft != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.StorageVolumeLeft))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8d
	}
	if m.StorageVolumeCap != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.StorageVolumeCap))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x85
	}
	{
		size, err := m.Location.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintHub(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	if m.DownloadVariance != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.DownloadVariance))))
		i--
		dAtA[i] = 0x75
	}
	if m.DownloadAverage != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.DownloadAverage))))
		i--
		dAtA[i] = 0x6d
	}
	if m.UploadVariance != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UploadVariance))))
		i--
		dAtA[i] = 0x65
	}
	if m.UploadAverage != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UploadAverage))))
		i--
		dAtA[i] = 0x5d
	}
	if m.Reputation != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Reputation))))
		i--
		dAtA[i] = 0x55
	}
	if m.Age != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.Age))
		i--
		dAtA[i] = 0x48
	}
	if m.Uptime != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Uptime))))
		i--
		dAtA[i] = 0x45
	}
	if m.HeartBeats != 0 {
		i = encodeVarintHub(dAtA, i, uint64(m.HeartBeats))
		i--
		dAtA[i] = 0x38
	}
	if m.Score != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Score))))
		i--
		dAtA[i] = 0x35
	}
	if len(m.BtfsVersion) > 0 {
		i -= len(m.BtfsVersion)
		copy(dAtA[i:], m.BtfsVersion)
		i = encodeVarintHub(dAtA, i, uint64(len(m.BtfsVersion)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Region) > 0 {
		i -= len(m.Region)
		copy(dAtA[i:], m.Region)
		i = encodeVarintHub(dAtA, i, uint64(len(m.Region)))
		i--
		dAtA[i] = 0x22
	}
	n12, err12 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.UpdateTimestamp, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.UpdateTimestamp):])
	if err12 != nil {
		return 0, err12
	}
	i -= n12
	i = encodeVarintHub(dAtA, i, uint64(n12))
	i--
	dAtA[i] = 0x1a
	n13, err13 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.CreateTimestamp, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.CreateTimestamp):])
	if err13 != nil {
		return 0, err13
	}
	i -= n13
	i = encodeVarintHub(dAtA, i, uint64(n13))
	i--
	dAtA[i] = 0x12
	if len(m.NodeId) > 0 {
		i -= len(m.NodeId)
		copy(dAtA[i:], m.NodeId)
		i = encodeVarintHub(dAtA, i, uint64(len(m.NodeId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Location) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Lon != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Lon))))
		i--
		dAtA[i] = 0x11
	}
	if m.Lat != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Lat))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func encodeVarintHub(dAtA []byte, offset int, v uint64) int {
	offset -= sovHub(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *NodesReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.NodeId) > 0 {
		for _, s := range m.NodeId {
			l = len(s)
			n += 1 + l + sovHub(uint64(l))
		}
	}
	l = len(m.RequesterId)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SettingsReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	if m.RespSize != 0 {
		n += 1 + sovHub(uint64(m.RespSize))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SettingsResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovHub(uint64(m.Code))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.ResponseTime)
	n += 1 + l + sovHub(uint64(l))
	if m.SettingsData != nil {
		l = m.SettingsData.Size()
		n += 1 + l + sovHub(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SettingsData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StoragePriceAsk != 0 {
		n += 9
	}
	if m.BandwidthPriceAsk != 0 {
		n += 9
	}
	if m.StorageTimeMin != 0 {
		n += 9
	}
	if m.BandwidthLimit != 0 {
		n += 9
	}
	if m.CollateralStake != 0 {
		n += 9
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HostsReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	if m.RespSize != 0 {
		n += 1 + sovHub(uint64(m.RespSize))
	}
	if m.Mode != 0 {
		n += 1 + sovHub(uint64(m.Mode))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RolesHostsReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	if m.RespSize != 0 {
		n += 1 + sovHub(uint64(m.RespSize))
	}
	if m.Role != 0 {
		n += 1 + sovHub(uint64(m.Role))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HostsResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovHub(uint64(m.Code))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	if m.Hosts != nil {
		l = m.Hosts.Size()
		n += 1 + l + sovHub(uint64(l))
	}
	if m.RespSize != 0 {
		n += 1 + sovHub(uint64(m.RespSize))
	}
	l = len(m.Mode)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.ResponseTime)
	n += 1 + l + sovHub(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StatsReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StatsResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovHub(uint64(m.Code))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.ResponseTime)
	n += 1 + l + sovHub(uint64(l))
	l = m.StorageStat_HostStats.Size()
	n += 1 + l + sovHub(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Candidate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NodeId)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	if m.HeartBeats != 0 {
		n += 1 + sovHub(uint64(m.HeartBeats))
	}
	if m.UploadAverage != 0 {
		n += 5
	}
	if m.UploadVariance != 0 {
		n += 5
	}
	if m.DownloadAverage != 0 {
		n += 5
	}
	if m.DownloadVariance != 0 {
		n += 5
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *RecycleReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EsIndex != 0 {
		n += 1 + sovHub(uint64(m.EsIndex))
	}
	if m.TimeScopeInHours != 0 {
		n += 1 + sovHub(uint64(m.TimeScopeInHours))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ParseResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovHub(uint64(m.Code))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.ResponseTime)
	n += 1 + l + sovHub(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *Host) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NodeId)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.CreateTimestamp)
	n += 1 + l + sovHub(uint64(l))
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.UpdateTimestamp)
	n += 1 + l + sovHub(uint64(l))
	l = len(m.Region)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	l = len(m.BtfsVersion)
	if l > 0 {
		n += 1 + l + sovHub(uint64(l))
	}
	if m.Score != 0 {
		n += 5
	}
	if m.HeartBeats != 0 {
		n += 1 + sovHub(uint64(m.HeartBeats))
	}
	if m.Uptime != 0 {
		n += 5
	}
	if m.Age != 0 {
		n += 1 + sovHub(uint64(m.Age))
	}
	if m.Reputation != 0 {
		n += 5
	}
	if m.UploadAverage != 0 {
		n += 5
	}
	if m.UploadVariance != 0 {
		n += 5
	}
	if m.DownloadAverage != 0 {
		n += 5
	}
	if m.DownloadVariance != 0 {
		n += 5
	}
	l = m.Location.Size()
	n += 1 + l + sovHub(uint64(l))
	if m.StorageVolumeCap != 0 {
		n += 6
	}
	if m.StorageVolumeLeft != 0 {
		n += 6
	}
	if m.StorageTimeMin != 0 {
		n += 2 + sovHub(uint64(m.StorageTimeMin))
	}
	if m.StoragePriceAsk != 0 {
		n += 2 + sovHub(uint64(m.StoragePriceAsk))
	}
	if m.StoragePriceEst != 0 {
		n += 2 + sovHub(uint64(m.StoragePriceEst))
	}
	if m.BandwidthLimit != 0 {
		n += 10
	}
	if m.BandwidthPriceAsk != 0 {
		n += 2 + sovHub(uint64(m.BandwidthPriceAsk))
	}
	if m.BandwidthPriceEst != 0 {
		n += 2 + sovHub(uint64(m.BandwidthPriceEst))
	}
	if m.CollateralStake != 0 {
		n += 2 + sovHub(uint64(m.CollateralStake))
	}
	if m.CollateralLost != 0 {
		n += 2 + sovHub(uint64(m.CollateralLost))
	}
	if m.CollateralBurn != 0 {
		n += 2 + sovHub(uint64(m.CollateralBurn))
	}
	l = len(m.CountryShort)
	if l > 0 {
		n += 2 + l + sovHub(uint64(l))
	}
	l = m.Node_ExperimentalFlags.Size()
	n += 2 + l + sovHub(uint64(l))
	if m.Discovery != 0 {
		n += 6
	}
	if m.UptimeScore != 0 {
		n += 6
	}
	if m.AgeScore != 0 {
		n += 6
	}
	if m.VersionScore != 0 {
		n += 6
	}
	if m.UploadSpeedScore != 0 {
		n += 6
	}
	if m.DownloadSpeedScore != 0 {
		n += 6
	}
	if len(m.Roles) > 0 {
		l = 0
		for _, e := range m.Roles {
			l += sovHub(uint64(e))
		}
		n += 2 + sovHub(uint64(l)) + l
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Location) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Lat != 0 {
		n += 9
	}
	if m.Lon != 0 {
		n += 9
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovHub(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozHub(x uint64) (n int) {
	return sovHub(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *NodesReq) 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 ErrIntOverflowHub
			}
			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: NodesReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodesReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeId = append(m.NodeId, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequesterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequesterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SettingsResp) 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 ErrIntOverflowHub
			}
			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: SettingsResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SettingsResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= ResponseCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResponseTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.ResponseTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SettingsData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SettingsData == nil {
				m.SettingsData = &SettingsData{}
			}
			if err := m.SettingsData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SettingsData) 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 ErrIntOverflowHub
			}
			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: SettingsData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SettingsData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoragePriceAsk", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.StoragePriceAsk = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field BandwidthPriceAsk", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.BandwidthPriceAsk = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageTimeMin", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.StorageTimeMin = float64(math.Float64frombits(v))
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field BandwidthLimit", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.BandwidthLimit = float64(math.Float64frombits(v))
		case 5:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollateralStake", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.CollateralStake = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipHub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostsReq) 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 ErrIntOverflowHub
			}
			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: HostsReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostsReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RespSize", wireType)
			}
			m.RespSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RespSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= HostsReq_Mode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RolesHostsReq) 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 ErrIntOverflowHub
			}
			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: RolesHostsReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RolesHostsReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RespSize", wireType)
			}
			m.RespSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RespSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
			}
			m.Role = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Role |= node.NodeRole(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostsResp) 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 ErrIntOverflowHub
			}
			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: HostsResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostsResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= ResponseCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hosts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Hosts == nil {
				m.Hosts = &HostsData{}
			}
			if err := m.Hosts.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RespSize", wireType)
			}
			m.RespSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RespSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResponseTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.ResponseTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StatsResp) 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 ErrIntOverflowHub
			}
			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: StatsResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatsResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= ResponseCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResponseTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.ResponseTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageStat_HostStats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.StorageStat_HostStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Candidate) 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 ErrIntOverflowHub
			}
			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: Candidate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Candidate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeartBeats", wireType)
			}
			m.HeartBeats = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HeartBeats |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field UploadAverage", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.UploadAverage = float32(math.Float32frombits(v))
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field UploadVariance", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.UploadVariance = float32(math.Float32frombits(v))
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownloadAverage", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.DownloadAverage = float32(math.Float32frombits(v))
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownloadVariance", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.DownloadVariance = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipHub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecycleReq) 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 ErrIntOverflowHub
			}
			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: RecycleReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecycleReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EsIndex", wireType)
			}
			m.EsIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EsIndex |= RecycleReq_ESIndex(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeScopeInHours", wireType)
			}
			m.TimeScopeInHours = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeScopeInHours |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Host) 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 ErrIntOverflowHub
			}
			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: Host: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Host: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateTimestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.CreateTimestamp, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateTimestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.UpdateTimestamp, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Region = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BtfsVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BtfsVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Score = float32(math.Float32frombits(v))
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeartBeats", wireType)
			}
			m.HeartBeats = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HeartBeats |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uptime", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Uptime = float32(math.Float32frombits(v))
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Age", wireType)
			}
			m.Age = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Age |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Reputation = float32(math.Float32frombits(v))
		case 11:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field UploadAverage", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.UploadAverage = float32(math.Float32frombits(v))
		case 12:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field UploadVariance", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.UploadVariance = float32(math.Float32frombits(v))
		case 13:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownloadAverage", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.DownloadAverage = float32(math.Float32frombits(v))
		case 14:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownloadVariance", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.DownloadVariance = float32(math.Float32frombits(v))
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Location.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageVolumeCap", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.StorageVolumeCap = float32(math.Float32frombits(v))
		case 17:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageVolumeLeft", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.StorageVolumeLeft = float32(math.Float32frombits(v))
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageTimeMin", wireType)
			}
			m.StorageTimeMin = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageTimeMin |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoragePriceAsk", wireType)
			}
			m.StoragePriceAsk = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoragePriceAsk |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoragePriceEst", wireType)
			}
			m.StoragePriceEst = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoragePriceEst |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 21:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field BandwidthLimit", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.BandwidthLimit = float64(math.Float64frombits(v))
		case 22:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BandwidthPriceAsk", wireType)
			}
			m.BandwidthPriceAsk = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BandwidthPriceAsk |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 23:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BandwidthPriceEst", wireType)
			}
			m.BandwidthPriceEst = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BandwidthPriceEst |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 24:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollateralStake", wireType)
			}
			m.CollateralStake = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CollateralStake |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 25:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollateralLost", wireType)
			}
			m.CollateralLost = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CollateralLost |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 26:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollateralBurn", wireType)
			}
			m.CollateralBurn = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CollateralBurn |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CountryShort", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CountryShort = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node_ExperimentalFlags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Node_ExperimentalFlags.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 29:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Discovery", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Discovery = float32(math.Float32frombits(v))
		case 30:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field UptimeScore", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.UptimeScore = float32(math.Float32frombits(v))
		case 31:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgeScore", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.AgeScore = float32(math.Float32frombits(v))
		case 32:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field VersionScore", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.VersionScore = float32(math.Float32frombits(v))
		case 33:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field UploadSpeedScore", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.UploadSpeedScore = float32(math.Float32frombits(v))
		case 34:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownloadSpeedScore", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.DownloadSpeedScore = float32(math.Float32frombits(v))
		case 35:
			if wireType == 0 {
				var v node.NodeRole
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowHub
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= node.NodeRole(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Roles = append(m.Roles, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowHub
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthHub
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthHub
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Roles) == 0 {
					m.Roles = make([]node.NodeRole, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v node.NodeRole
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowHub
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= node.NodeRole(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Roles = append(m.Roles, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Location) 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 ErrIntOverflowHub
			}
			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: Location: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Location: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lat", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Lat = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lon", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Lon = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipHub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipHub(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowHub
			}
			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, ErrIntOverflowHub
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowHub
				}
				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, ErrInvalidLengthHub
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupHub
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthHub
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthHub        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowHub          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupHub = fmt.Errorf("proto: unexpected end of group")
)