node.pb.go

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

package node

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/types"
	golang_proto "github.com/golang/protobuf/proto"
	guard "github.com/tron-us/go-btfs-common/protos/guard"
	_ "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"
	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 NodeRole int32

const (
	NodeRole_RENTER             NodeRole = 0
	NodeRole_HOST               NodeRole = 1
	NodeRole_REPAIRER           NodeRole = 2
	NodeRole_CHALLENGER         NodeRole = 3
	NodeRole_NETWORK_CHECKER    NodeRole = 4
	NodeRole_REPUTATION_CHECKER NodeRole = 5
	NodeRole_CDN_PROVIDER       NodeRole = 6
	NodeRole_OTHER              NodeRole = 20
)

var NodeRole_name = map[int32]string{
	0:  "RENTER",
	1:  "HOST",
	2:  "REPAIRER",
	3:  "CHALLENGER",
	4:  "NETWORK_CHECKER",
	5:  "REPUTATION_CHECKER",
	6:  "CDN_PROVIDER",
	20: "OTHER",
}

var NodeRole_value = map[string]int32{
	"RENTER":             0,
	"HOST":               1,
	"REPAIRER":           2,
	"CHALLENGER":         3,
	"NETWORK_CHECKER":    4,
	"REPUTATION_CHECKER": 5,
	"CDN_PROVIDER":       6,
	"OTHER":              20,
}

func (x NodeRole) String() string {
	return proto.EnumName(NodeRole_name, int32(x))
}

func (NodeRole) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_35f8e1f5ec2240a2, []int{0}
}

type DiscoveryErrorCode int32

const (
	DiscoveryErrorCode_SUCCESS           DiscoveryErrorCode = 0
	DiscoveryErrorCode_UNCONNECTED       DiscoveryErrorCode = 1
	DiscoveryErrorCode_TIMEOUT           DiscoveryErrorCode = 2
	DiscoveryErrorCode_ABSOLUTELY_UNOPEN DiscoveryErrorCode = 3
	DiscoveryErrorCode_OTHER_REASON      DiscoveryErrorCode = 10
)

var DiscoveryErrorCode_name = map[int32]string{
	0:  "SUCCESS",
	1:  "UNCONNECTED",
	2:  "TIMEOUT",
	3:  "ABSOLUTELY_UNOPEN",
	10: "OTHER_REASON",
}

var DiscoveryErrorCode_value = map[string]int32{
	"SUCCESS":           0,
	"UNCONNECTED":       1,
	"TIMEOUT":           2,
	"ABSOLUTELY_UNOPEN": 3,
	"OTHER_REASON":      10,
}

func (x DiscoveryErrorCode) String() string {
	return proto.EnumName(DiscoveryErrorCode_name, int32(x))
}

func (DiscoveryErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_35f8e1f5ec2240a2, []int{1}
}

type ContractStat_Role int32

const (
	ContractStat_HOST     ContractStat_Role = 0
	ContractStat_RENTER   ContractStat_Role = 1
	ContractStat_RESERVED ContractStat_Role = 2
)

var ContractStat_Role_name = map[int32]string{
	0: "HOST",
	1: "RENTER",
	2: "RESERVED",
}

var ContractStat_Role_value = map[string]int32{
	"HOST":     0,
	"RENTER":   1,
	"RESERVED": 2,
}

func (x ContractStat_Role) String() string {
	return proto.EnumName(ContractStat_Role_name, int32(x))
}

func (ContractStat_Role) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_35f8e1f5ec2240a2, []int{5, 0}
}

type PayLoadInfo struct {
	NodeId               string           `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty" pg:"node_id"`
	Node                 *Node            `protobuf:"bytes,2,opt,name=node,proto3" json:"node,omitempty" pg:"node"`
	DiscoveryNodes       []*DiscoveryNode `protobuf:"bytes,3,rep,name=discovery_nodes,json=discoveryNodes,proto3" json:"discovery_nodes,omitempty" pg:"discovery_nodes"`
	LastTime             time.Time        `protobuf:"bytes,4,opt,name=last_time,json=lastTime,proto3,stdtime" json:"last_time" pg:"last_time"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-" pg:"-"`
	XXX_unrecognized     []byte           `json:"-" pg:"-"`
	XXX_sizecache        int32            `json:"-" pg:"-"`
}

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

var xxx_messageInfo_PayLoadInfo proto.InternalMessageInfo

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

func (m *PayLoadInfo) GetNode() *Node {
	if m != nil {
		return m.Node
	}
	return nil
}

func (m *PayLoadInfo) GetDiscoveryNodes() []*DiscoveryNode {
	if m != nil {
		return m.DiscoveryNodes
	}
	return nil
}

func (m *PayLoadInfo) GetLastTime() time.Time {
	if m != nil {
		return m.LastTime
	}
	return time.Time{}
}

func (*PayLoadInfo) XXX_MessageName() string {
	return "node.PayLoadInfo"
}

type DiscoveryNode struct {
	ToNodeId             string             `protobuf:"bytes,1,opt,name=to_node_id,json=toNodeId,proto3" json:"to_node_id,omitempty" pg:"to_node_id"`
	NodeConnectLatency   int32              `protobuf:"varint,2,opt,name=node_connect_latency,json=nodeConnectLatency,proto3" json:"node_connect_latency,omitempty" pg:"node_connect_latency"`
	ErrCode              DiscoveryErrorCode `protobuf:"varint,3,opt,name=err_code,json=errCode,proto3,enum=node.DiscoveryErrorCode" json:"err_code,omitempty" pg:"err_code"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-" pg:"-"`
	XXX_unrecognized     []byte             `json:"-" pg:"-"`
	XXX_sizecache        int32              `json:"-" pg:"-"`
}

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

var xxx_messageInfo_DiscoveryNode proto.InternalMessageInfo

func (m *DiscoveryNode) GetToNodeId() string {
	if m != nil {
		return m.ToNodeId
	}
	return ""
}

func (m *DiscoveryNode) GetNodeConnectLatency() int32 {
	if m != nil {
		return m.NodeConnectLatency
	}
	return 0
}

func (m *DiscoveryNode) GetErrCode() DiscoveryErrorCode {
	if m != nil {
		return m.ErrCode
	}
	return DiscoveryErrorCode_SUCCESS
}

func (*DiscoveryNode) XXX_MessageName() string {
	return "node.DiscoveryNode"
}

type DiscoveryTab struct {
	tableName            string             `pg:"node_discovery,alias:t,discard_unknown_columns"`
	NodeId               string             `protobuf:"bytes,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty" pg:"node_id"`
	ConnectCnt           uint32             `protobuf:"varint,3,opt,name=connect_cnt,json=connectCnt,proto3" json:"connect_cnt,omitempty" pg:"connect_cnt"`
	AvgConnectLatency    int32              `protobuf:"varint,4,opt,name=avg_connect_latency,json=avgConnectLatency,proto3" json:"avg_connect_latency,omitempty" pg:"avg_connect_latency"`
	ErrCode              DiscoveryErrorCode `protobuf:"varint,5,opt,name=err_code,json=errCode,proto3,enum=node.DiscoveryErrorCode" json:"err_code,omitempty" pg:"err_code"`
	DiscoveryLabel       int32              `protobuf:"varint,6,opt,name=discovery_label,json=discoveryLabel,proto3" json:"discovery_label,omitempty" pg:"discovery_label"`
	TimeCreated          time.Time          `protobuf:"bytes,7,opt,name=time_created,json=timeCreated,proto3,stdtime" json:"time_created" pg:"time_created"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-" pg:"-"`
	XXX_unrecognized     []byte             `json:"-" pg:"-"`
	XXX_sizecache        int32              `json:"-" pg:"-"`
}

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

var xxx_messageInfo_DiscoveryTab proto.InternalMessageInfo

func (m *DiscoveryTab) GettableName() string {
	if m != nil {
		return m.tableName
	}
	return ""
}

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

func (m *DiscoveryTab) GetConnectCnt() uint32 {
	if m != nil {
		return m.ConnectCnt
	}
	return 0
}

func (m *DiscoveryTab) GetAvgConnectLatency() int32 {
	if m != nil {
		return m.AvgConnectLatency
	}
	return 0
}

func (m *DiscoveryTab) GetErrCode() DiscoveryErrorCode {
	if m != nil {
		return m.ErrCode
	}
	return DiscoveryErrorCode_SUCCESS
}

func (m *DiscoveryTab) GetDiscoveryLabel() int32 {
	if m != nil {
		return m.DiscoveryLabel
	}
	return 0
}

func (m *DiscoveryTab) GetTimeCreated() time.Time {
	if m != nil {
		return m.TimeCreated
	}
	return time.Time{}
}

func (*DiscoveryTab) XXX_MessageName() string {
	return "node.DiscoveryTab"
}

type Node struct {
	tableName              string  `pg:"node_metrics,alias:t,discard_unknown_columns"`
	NodeId                 string  `protobuf:"bytes,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty" pg:"node_id"`
	BtfsVersion            string  `protobuf:"bytes,3,opt,name=btfs_version,json=btfsVersion,proto3" json:"btfs_version,omitempty" pg:"btfs_version"`
	UpTime                 uint64  `protobuf:"varint,4,opt,name=up_time,json=upTime,proto3" json:"up_time,omitempty" pg:"up_time"`
	StorageUsed            uint64  `protobuf:"varint,5,opt,name=storage_used,json=storageUsed,proto3" json:"storage_used,omitempty" pg:"storage_used"`
	StorageVolumeCap       uint64  `protobuf:"varint,6,opt,name=storage_volume_cap,json=storageVolumeCap,proto3" json:"storage_volume_cap,omitempty" pg:"storage_volume_cap"`
	MemoryUsed             uint64  `protobuf:"varint,7,opt,name=memory_used,json=memoryUsed,proto3" json:"memory_used,omitempty" pg:"memory_used"`
	CpuUsed                float64 `protobuf:"fixed64,8,opt,name=cpu_used,json=cpuUsed,proto3" json:"cpu_used,omitempty" pg:"cpu_used"`
	Upload                 uint64  `protobuf:"varint,9,opt,name=upload,proto3" json:"upload,omitempty" pg:"upload"`
	Download               uint64  `protobuf:"varint,10,opt,name=download,proto3" json:"download,omitempty" pg:"download"`
	TotalUpload            uint64  `protobuf:"varint,11,opt,name=total_upload,json=totalUpload,proto3" json:"total_upload,omitempty" pg:"total_upload"`
	TotalDownload          uint64  `protobuf:"varint,12,opt,name=total_download,json=totalDownload,proto3" json:"total_download,omitempty" pg:"total_download"`
	StoragePriceDeal       uint64  `protobuf:"varint,13,opt,name=storage_price_deal,json=storagePriceDeal,proto3" json:"storage_price_deal,omitempty" pg:"storage_price_deal"`
	BandwidthPriceDeal     uint64  `protobuf:"varint,14,opt,name=bandwidth_price_deal,json=bandwidthPriceDeal,proto3" json:"bandwidth_price_deal,omitempty" pg:"bandwidth_price_deal"`
	Node_Settings          `protobuf:"bytes,15,opt,name=settings,proto3,embedded=settings" json:"settings" pg:"settings"`
	Reputation             float64   `protobuf:"fixed64,16,opt,name=reputation,proto3" json:"reputation,omitempty" pg:"reputation"`
	BlocksUp               uint64    `protobuf:"varint,17,opt,name=blocks_up,json=blocksUp,proto3" json:"blocks_up,omitempty" pg:"blocks_up"`
	BlocksDown             uint64    `protobuf:"varint,18,opt,name=blocks_down,json=blocksDown,proto3" json:"blocks_down,omitempty" pg:"blocks_down"`
	OsType                 string    `protobuf:"bytes,19,opt,name=os_type,json=osType,proto3" json:"os_type,omitempty" pg:"os_type"`
	ArchType               string    `protobuf:"bytes,20,opt,name=arch_type,json=archType,proto3" json:"arch_type,omitempty" pg:"arch_type"`
	CpuInfo                string    `protobuf:"bytes,21,opt,name=cpu_info,json=cpuInfo,proto3" json:"cpu_info,omitempty" pg:"cpu_info"`
	PeersConnected         uint64    `protobuf:"varint,23,opt,name=peers_connected,json=peersConnected,proto3" json:"peers_connected,omitempty" pg:"peers_connected"`
	TimeCreated            time.Time `protobuf:"bytes,24,opt,name=time_created,json=timeCreated,proto3,stdtime" json:"time_created" pg:"time_created"`
	HVal                   string    `protobuf:"bytes,25,opt,name=h_val,json=hVal,proto3" json:"h_val,omitempty" pg:"h_val"`
	Node_Geo               `protobuf:"bytes,26,opt,name=geo,proto3,embedded=geo" json:"geo" pg:"geo"`
	Node_ExperimentalFlags `protobuf:"bytes,27,opt,name=flg,proto3,embedded=flg" json:"flg" pg:"flg"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-" pg:"-"`
	XXX_unrecognized       []byte   `json:"-" pg:"-"`
	XXX_sizecache          int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Node proto.InternalMessageInfo

func (m *Node) GettableName() string {
	if m != nil {
		return m.tableName
	}
	return ""
}

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

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

func (m *Node) GetUpTime() uint64 {
	if m != nil {
		return m.UpTime
	}
	return 0
}

func (m *Node) GetStorageUsed() uint64 {
	if m != nil {
		return m.StorageUsed
	}
	return 0
}

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

func (m *Node) GetMemoryUsed() uint64 {
	if m != nil {
		return m.MemoryUsed
	}
	return 0
}

func (m *Node) GetCpuUsed() float64 {
	if m != nil {
		return m.CpuUsed
	}
	return 0
}

func (m *Node) GetUpload() uint64 {
	if m != nil {
		return m.Upload
	}
	return 0
}

func (m *Node) GetDownload() uint64 {
	if m != nil {
		return m.Download
	}
	return 0
}

func (m *Node) GetTotalUpload() uint64 {
	if m != nil {
		return m.TotalUpload
	}
	return 0
}

func (m *Node) GetTotalDownload() uint64 {
	if m != nil {
		return m.TotalDownload
	}
	return 0
}

func (m *Node) GetStoragePriceDeal() uint64 {
	if m != nil {
		return m.StoragePriceDeal
	}
	return 0
}

func (m *Node) GetBandwidthPriceDeal() uint64 {
	if m != nil {
		return m.BandwidthPriceDeal
	}
	return 0
}

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

func (m *Node) GetBlocksUp() uint64 {
	if m != nil {
		return m.BlocksUp
	}
	return 0
}

func (m *Node) GetBlocksDown() uint64 {
	if m != nil {
		return m.BlocksDown
	}
	return 0
}

func (m *Node) GetOsType() string {
	if m != nil {
		return m.OsType
	}
	return ""
}

func (m *Node) GetArchType() string {
	if m != nil {
		return m.ArchType
	}
	return ""
}

func (m *Node) GetCpuInfo() string {
	if m != nil {
		return m.CpuInfo
	}
	return ""
}

func (m *Node) GetPeersConnected() uint64 {
	if m != nil {
		return m.PeersConnected
	}
	return 0
}

func (m *Node) GetTimeCreated() time.Time {
	if m != nil {
		return m.TimeCreated
	}
	return time.Time{}
}

func (m *Node) GetHVal() string {
	if m != nil {
		return m.HVal
	}
	return ""
}

func (*Node) XXX_MessageName() string {
	return "node.Node"
}

type Node_Settings struct {
	StoragePriceAsk            uint64     `protobuf:"varint,1,opt,name=storage_price_ask,json=storagePriceAsk,proto3" json:"storage_price_ask,omitempty" pg:"storage_price_ask"`
	BandwidthPriceAsk          uint64     `protobuf:"varint,2,opt,name=bandwidth_price_ask,json=bandwidthPriceAsk,proto3" json:"bandwidth_price_ask,omitempty" pg:"bandwidth_price_ask"`
	StorageTimeMin             uint64     `protobuf:"varint,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            uint64     `protobuf:"varint,5,opt,name=collateral_stake,json=collateralStake,proto3" json:"collateral_stake,omitempty" pg:"collateral_stake"`
	StoragePriceDefault        uint64     `protobuf:"varint,6,opt,name=storage_price_default,json=storagePriceDefault,proto3" json:"storage_price_default,omitempty" pg:"storage_price_default"`
	CustomizedPricing          bool       `protobuf:"varint,7,opt,name=customized_pricing,json=customizedPricing,proto3" json:"customized_pricing,omitempty" pg:"customized_pricing"`
	Roles                      []NodeRole `protobuf:"varint,8,rep,packed,name=roles,proto3,enum=node.NodeRole" json:"roles,omitempty" pg:"roles,array"`
	RepairPriceDefault         uint64     `protobuf:"varint,9,opt,name=repair_price_default,json=repairPriceDefault,proto3" json:"repair_price_default,omitempty" pg:"repair_price_default"`
	RepairPriceCustomized      uint64     `protobuf:"varint,10,opt,name=repair_price_customized,json=repairPriceCustomized,proto3" json:"repair_price_customized,omitempty" pg:"repair_price_customized"`
	RepairCustomizedPricing    bool       `protobuf:"varint,11,opt,name=repair_customized_pricing,json=repairCustomizedPricing,proto3" json:"repair_customized_pricing,omitempty" pg:"repair_customized_pricing"`
	ChallengePriceDefault      uint64     `protobuf:"varint,12,opt,name=challenge_price_default,json=challengePriceDefault,proto3" json:"challenge_price_default,omitempty" pg:"challenge_price_default"`
	ChallengePriceCustomized   uint64     `protobuf:"varint,13,opt,name=challenge_price_customized,json=challengePriceCustomized,proto3" json:"challenge_price_customized,omitempty" pg:"challenge_price_customized"`
	ChallengeCustomizedPricing bool       `protobuf:"varint,14,opt,name=challenge_customized_pricing,json=challengeCustomizedPricing,proto3" json:"challenge_customized_pricing,omitempty" pg:"challenge_customized_pricing"`
	XXX_NoUnkeyedLiteral       struct{}   `json:"-" pg:"-"`
	XXX_unrecognized           []byte     `json:"-" pg:"-"`
	XXX_sizecache              int32      `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Node_Settings proto.InternalMessageInfo

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

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

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

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

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

func (m *Node_Settings) GetStoragePriceDefault() uint64 {
	if m != nil {
		return m.StoragePriceDefault
	}
	return 0
}

func (m *Node_Settings) GetCustomizedPricing() bool {
	if m != nil {
		return m.CustomizedPricing
	}
	return false
}

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

func (m *Node_Settings) GetRepairPriceDefault() uint64 {
	if m != nil {
		return m.RepairPriceDefault
	}
	return 0
}

func (m *Node_Settings) GetRepairPriceCustomized() uint64 {
	if m != nil {
		return m.RepairPriceCustomized
	}
	return 0
}

func (m *Node_Settings) GetRepairCustomizedPricing() bool {
	if m != nil {
		return m.RepairCustomizedPricing
	}
	return false
}

func (m *Node_Settings) GetChallengePriceDefault() uint64 {
	if m != nil {
		return m.ChallengePriceDefault
	}
	return 0
}

func (m *Node_Settings) GetChallengePriceCustomized() uint64 {
	if m != nil {
		return m.ChallengePriceCustomized
	}
	return 0
}

func (m *Node_Settings) GetChallengeCustomizedPricing() bool {
	if m != nil {
		return m.ChallengeCustomizedPricing
	}
	return false
}

func (*Node_Settings) XXX_MessageName() string {
	return "node.Node.Settings"
}

type Node_Geo struct {
	CountryShort         string   `protobuf:"bytes,1,opt,name=country_short,json=countryShort,proto3" json:"country_short,omitempty" pg:"country_short"`
	Region               string   `protobuf:"bytes,2,opt,name=region,proto3" json:"region,omitempty" pg:"region"`
	Latitude             float32  `protobuf:"fixed32,3,opt,name=latitude,proto3" json:"latitude,omitempty" pg:"latitude"`
	Longitude            float32  `protobuf:"fixed32,4,opt,name=longitude,proto3" json:"longitude,omitempty" pg:"longitude"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Node_Geo proto.InternalMessageInfo

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

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

func (m *Node_Geo) GetLatitude() float32 {
	if m != nil {
		return m.Latitude
	}
	return 0
}

func (m *Node_Geo) GetLongitude() float32 {
	if m != nil {
		return m.Longitude
	}
	return 0
}

func (*Node_Geo) XXX_MessageName() string {
	return "node.Node.Geo"
}

type Node_ExperimentalFlags struct {
	Analytics            bool     `protobuf:"varint,1,opt,name=analytics,proto3" json:"analytics,omitempty" pg:"analytics"`
	FilestoreEnabled     bool     `protobuf:"varint,2,opt,name=filestore_enabled,json=filestoreEnabled,proto3" json:"filestore_enabled,omitempty" pg:"filestore_enabled"`
	HostsSyncEnabled     bool     `protobuf:"varint,3,opt,name=hosts_sync_enabled,json=hostsSyncEnabled,proto3" json:"hosts_sync_enabled,omitempty" pg:"hosts_sync_enabled"`
	HostsSyncMode        string   `protobuf:"bytes,4,opt,name=hosts_sync_mode,json=hostsSyncMode,proto3" json:"hosts_sync_mode,omitempty" pg:"hosts_sync_mode"`
	Libp2PStreamMounting bool     `protobuf:"varint,5,opt,name=libp2p_stream_mounting,json=libp2pStreamMounting,proto3" json:"libp2p_stream_mounting,omitempty" pg:"libp2p_stream_mounting"`
	P2PHttpProxy         bool     `protobuf:"varint,6,opt,name=p2p_http_proxy,json=p2pHttpProxy,proto3" json:"p2p_http_proxy,omitempty" pg:"p2p_http_proxy"`
	PreferTls            bool     `protobuf:"varint,7,opt,name=prefer_tls,json=preferTls,proto3" json:"prefer_tls,omitempty" pg:"prefer_tls"`
	Quic                 bool     `protobuf:"varint,8,opt,name=quic,proto3" json:"quic,omitempty" pg:"quic"`
	RemoveOnUnpin        bool     `protobuf:"varint,9,opt,name=remove_on_unpin,json=removeOnUnpin,proto3" json:"remove_on_unpin,omitempty" pg:"remove_on_unpin"`
	ShardingEnabled      bool     `protobuf:"varint,10,opt,name=sharding_enabled,json=shardingEnabled,proto3" json:"sharding_enabled,omitempty" pg:"sharding_enabled"`
	StorageClientEnabled bool     `protobuf:"varint,11,opt,name=storage_client_enabled,json=storageClientEnabled,proto3" json:"storage_client_enabled,omitempty" pg:"storage_client_enabled"`
	StorageHostEnabled   bool     `protobuf:"varint,12,opt,name=storage_host_enabled,json=storageHostEnabled,proto3" json:"storage_host_enabled,omitempty" pg:"storage_host_enabled"`
	StrategicProviding   bool     `protobuf:"varint,13,opt,name=strategic_providing,json=strategicProviding,proto3" json:"strategic_providing,omitempty" pg:"strategic_providing"`
	UrlStoreEnabled      bool     `protobuf:"varint,14,opt,name=url_store_enabled,json=urlStoreEnabled,proto3" json:"url_store_enabled,omitempty" pg:"url_store_enabled"`
	DisableAutoUpdate    bool     `protobuf:"varint,15,opt,name=disable_auto_update,json=disableAutoUpdate,proto3" json:"disable_auto_update,omitempty" pg:"disable_auto_update"`
	GraphsyncEnabled     bool     `protobuf:"varint,16,opt,name=graphsync_enabled,json=graphsyncEnabled,proto3" json:"graphsync_enabled,omitempty" pg:"graphsync_enabled"`
	RepairHostEnabled    bool     `protobuf:"varint,17,opt,name=repair_host_enabled,json=repairHostEnabled,proto3" json:"repair_host_enabled,omitempty" pg:"repair_host_enabled"`
	ChallengeHostEnabled bool     `protobuf:"varint,18,opt,name=challenge_host_enabled,json=challengeHostEnabled,proto3" json:"challenge_host_enabled,omitempty" pg:"challenge_host_enabled"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Node_ExperimentalFlags proto.InternalMessageInfo

func (m *Node_ExperimentalFlags) GetAnalytics() bool {
	if m != nil {
		return m.Analytics
	}
	return false
}

func (m *Node_ExperimentalFlags) GetFilestoreEnabled() bool {
	if m != nil {
		return m.FilestoreEnabled
	}
	return false
}

func (m *Node_ExperimentalFlags) GetHostsSyncEnabled() bool {
	if m != nil {
		return m.HostsSyncEnabled
	}
	return false
}

func (m *Node_ExperimentalFlags) GetHostsSyncMode() string {
	if m != nil {
		return m.HostsSyncMode
	}
	return ""
}

func (m *Node_ExperimentalFlags) GetLibp2PStreamMounting() bool {
	if m != nil {
		return m.Libp2PStreamMounting
	}
	return false
}

func (m *Node_ExperimentalFlags) GetP2PHttpProxy() bool {
	if m != nil {
		return m.P2PHttpProxy
	}
	return false
}

func (m *Node_ExperimentalFlags) GetPreferTls() bool {
	if m != nil {
		return m.PreferTls
	}
	return false
}

func (m *Node_ExperimentalFlags) GetQuic() bool {
	if m != nil {
		return m.Quic
	}
	return false
}

func (m *Node_ExperimentalFlags) GetRemoveOnUnpin() bool {
	if m != nil {
		return m.RemoveOnUnpin
	}
	return false
}

func (m *Node_ExperimentalFlags) GetShardingEnabled() bool {
	if m != nil {
		return m.ShardingEnabled
	}
	return false
}

func (m *Node_ExperimentalFlags) GetStorageClientEnabled() bool {
	if m != nil {
		return m.StorageClientEnabled
	}
	return false
}

func (m *Node_ExperimentalFlags) GetStorageHostEnabled() bool {
	if m != nil {
		return m.StorageHostEnabled
	}
	return false
}

func (m *Node_ExperimentalFlags) GetStrategicProviding() bool {
	if m != nil {
		return m.StrategicProviding
	}
	return false
}

func (m *Node_ExperimentalFlags) GetUrlStoreEnabled() bool {
	if m != nil {
		return m.UrlStoreEnabled
	}
	return false
}

func (m *Node_ExperimentalFlags) GetDisableAutoUpdate() bool {
	if m != nil {
		return m.DisableAutoUpdate
	}
	return false
}

func (m *Node_ExperimentalFlags) GetGraphsyncEnabled() bool {
	if m != nil {
		return m.GraphsyncEnabled
	}
	return false
}

func (m *Node_ExperimentalFlags) GetRepairHostEnabled() bool {
	if m != nil {
		return m.RepairHostEnabled
	}
	return false
}

func (m *Node_ExperimentalFlags) GetChallengeHostEnabled() bool {
	if m != nil {
		return m.ChallengeHostEnabled
	}
	return false
}

func (*Node_ExperimentalFlags) XXX_MessageName() string {
	return "node.Node.ExperimentalFlags"
}

type StorageStat struct {
	HostStats            StorageStat_Host   `protobuf:"bytes,1,opt,name=host_stats,json=hostStats,proto3" json:"host_stats" pg:"host_stats"`
	RenterStats          StorageStat_Renter `protobuf:"bytes,2,opt,name=renter_stats,json=renterStats,proto3" json:"renter_stats" pg:"renter_stats"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-" pg:"-"`
	XXX_unrecognized     []byte             `json:"-" pg:"-"`
	XXX_sizecache        int32              `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StorageStat proto.InternalMessageInfo

func (m *StorageStat) GetHostStats() StorageStat_Host {
	if m != nil {
		return m.HostStats
	}
	return StorageStat_Host{}
}

func (m *StorageStat) GetRenterStats() StorageStat_Renter {
	if m != nil {
		return m.RenterStats
	}
	return StorageStat_Renter{}
}

func (*StorageStat) XXX_MessageName() string {
	return "node.StorageStat"
}

type StorageStat_HostStats struct {
	Uptime               float32   `protobuf:"fixed32,1,opt,name=uptime,proto3" json:"uptime" pg:"uptime"`
	Score                float32   `protobuf:"fixed32,2,opt,name=score,proto3" json:"score" pg:"score"`
	UptimeScore          float32   `protobuf:"fixed32,3,opt,name=uptime_score,json=uptimeScore,proto3" json:"uptime_score" pg:"uptime_score"`
	AgeScore             float32   `protobuf:"fixed32,4,opt,name=age_score,json=ageScore,proto3" json:"age_score" pg:"age_score"`
	VersionScore         float32   `protobuf:"fixed32,5,opt,name=version_score,json=versionScore,proto3" json:"version_score" pg:"version_score"`
	SpeedScore           float32   `protobuf:"fixed32,6,opt,name=speed_score,json=speedScore,proto3" json:"speed_score" pg:"speed_score"`
	UploadSpeedScore     float32   `protobuf:"fixed32,7,opt,name=upload_speed_score,json=uploadSpeedScore,proto3" json:"upload_speed_score" pg:"upload_speed_score"`
	DownloadSpeedScore   float32   `protobuf:"fixed32,8,opt,name=download_speed_score,json=downloadSpeedScore,proto3" json:"download_speed_score" pg:"download_speed_score"`
	UptimeWeight         float32   `protobuf:"fixed32,9,opt,name=uptime_weight,json=uptimeWeight,proto3" json:"uptime_weight" pg:"uptime_weight"`
	AgeWeight            float32   `protobuf:"fixed32,10,opt,name=age_weight,json=ageWeight,proto3" json:"age_weight" pg:"age_weight"`
	VersionWeight        float32   `protobuf:"fixed32,11,opt,name=version_weight,json=versionWeight,proto3" json:"version_weight" pg:"version_weight"`
	SpeedWeight          float32   `protobuf:"fixed32,12,opt,name=speed_weight,json=speedWeight,proto3" json:"speed_weight" pg:"speed_weight"`
	UploadSpeedWeight    float32   `protobuf:"fixed32,13,opt,name=upload_speed_weight,json=uploadSpeedWeight,proto3" json:"upload_speed_weight" pg:"upload_speed_weight"`
	DownloadSpeedWeight  float32   `protobuf:"fixed32,14,opt,name=download_speed_weight,json=downloadSpeedWeight,proto3" json:"download_speed_weight" pg:"download_speed_weight"`
	LastUpdated          time.Time `protobuf:"bytes,15,opt,name=last_updated,json=lastUpdated,proto3,stdtime" json:"last_updated" pg:"last_updated"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
	XXX_unrecognized     []byte    `json:"-" pg:"-"`
	XXX_sizecache        int32     `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StorageStat_HostStats proto.InternalMessageInfo

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

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

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

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

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

func (m *StorageStat_HostStats) GetSpeedScore() float32 {
	if m != nil {
		return m.SpeedScore
	}
	return 0
}

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

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

func (m *StorageStat_HostStats) GetUptimeWeight() float32 {
	if m != nil {
		return m.UptimeWeight
	}
	return 0
}

func (m *StorageStat_HostStats) GetAgeWeight() float32 {
	if m != nil {
		return m.AgeWeight
	}
	return 0
}

func (m *StorageStat_HostStats) GetVersionWeight() float32 {
	if m != nil {
		return m.VersionWeight
	}
	return 0
}

func (m *StorageStat_HostStats) GetSpeedWeight() float32 {
	if m != nil {
		return m.SpeedWeight
	}
	return 0
}

func (m *StorageStat_HostStats) GetUploadSpeedWeight() float32 {
	if m != nil {
		return m.UploadSpeedWeight
	}
	return 0
}

func (m *StorageStat_HostStats) GetDownloadSpeedWeight() float32 {
	if m != nil {
		return m.DownloadSpeedWeight
	}
	return 0
}

func (m *StorageStat_HostStats) GetLastUpdated() time.Time {
	if m != nil {
		return m.LastUpdated
	}
	return time.Time{}
}

func (*StorageStat_HostStats) XXX_MessageName() string {
	return "node.StorageStat.HostStats"
}

type StorageStat_Host struct {
	Online                bool  `protobuf:"varint,1,opt,name=online,proto3" json:"online" pg:"online"`
	StorageUsed           int64 `protobuf:"varint,2,opt,name=storage_used,json=storageUsed,proto3" json:"storage_used" pg:"storage_used"`
	StorageCap            int64 `protobuf:"varint,3,opt,name=storage_cap,json=storageCap,proto3" json:"storage_cap" pg:"storage_cap"`
	StorageDiskTotal      int64 `protobuf:"varint,4,opt,name=storage_disk_total,json=storageDiskTotal,proto3" json:"storage_disk_total" pg:"storage_disk_total"`
	StorageDiskAvailable  int64 `protobuf:"varint,5,opt,name=storage_disk_available,json=storageDiskAvailable,proto3" json:"storage_disk_available" pg:"storage_disk_available"`
	StorageStat_HostStats `protobuf:"bytes,6,opt,name=stats,proto3,embedded=stats" json:"" pg:""`
	XXX_NoUnkeyedLiteral  struct{} `json:"-" pg:"-"`
	XXX_unrecognized      []byte   `json:"-" pg:"-"`
	XXX_sizecache         int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StorageStat_Host proto.InternalMessageInfo

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

func (m *StorageStat_Host) GetStorageUsed() int64 {
	if m != nil {
		return m.StorageUsed
	}
	return 0
}

func (m *StorageStat_Host) GetStorageCap() int64 {
	if m != nil {
		return m.StorageCap
	}
	return 0
}

func (m *StorageStat_Host) GetStorageDiskTotal() int64 {
	if m != nil {
		return m.StorageDiskTotal
	}
	return 0
}

func (m *StorageStat_Host) GetStorageDiskAvailable() int64 {
	if m != nil {
		return m.StorageDiskAvailable
	}
	return 0
}

func (*StorageStat_Host) XXX_MessageName() string {
	return "node.StorageStat.Host"
}

type StorageStat_Renter struct {
	Reserved             string   `protobuf:"bytes,1,opt,name=reserved,proto3" json:"reserved" pg:"reserved"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StorageStat_Renter proto.InternalMessageInfo

func (m *StorageStat_Renter) GetReserved() string {
	if m != nil {
		return m.Reserved
	}
	return ""
}

func (*StorageStat_Renter) XXX_MessageName() string {
	return "node.StorageStat.Renter"
}

type ContractStat struct {
	ActiveContractNum       int64             `protobuf:"varint,1,opt,name=active_contract_num,json=activeContractNum,proto3" json:"active_contract_num" pg:"active_contract_num"`
	CompensationPaid        int64             `protobuf:"varint,2,opt,name=compensation_paid,json=compensationPaid,proto3" json:"compensation_paid" pg:"compensation_paid"`
	CompensationOutstanding int64             `protobuf:"varint,3,opt,name=compensation_outstanding,json=compensationOutstanding,proto3" json:"compensation_outstanding" pg:"compensation_outstanding"`
	FirstContractStart      time.Time         `protobuf:"bytes,4,opt,name=first_contract_start,json=firstContractStart,proto3,stdtime" json:"first_contract_start" pg:"first_contract_start"`
	LastContractEnd         time.Time         `protobuf:"bytes,5,opt,name=last_contract_end,json=lastContractEnd,proto3,stdtime" json:"last_contract_end" pg:"last_contract_end"`
	Role                    ContractStat_Role `protobuf:"varint,6,opt,name=role,proto3,enum=node.ContractStat_Role" json:"role" pg:"role"`
	XXX_NoUnkeyedLiteral    struct{}          `json:"-" pg:"-"`
	XXX_unrecognized        []byte            `json:"-" pg:"-"`
	XXX_sizecache           int32             `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ContractStat proto.InternalMessageInfo

func (m *ContractStat) GetActiveContractNum() int64 {
	if m != nil {
		return m.ActiveContractNum
	}
	return 0
}

func (m *ContractStat) GetCompensationPaid() int64 {
	if m != nil {
		return m.CompensationPaid
	}
	return 0
}

func (m *ContractStat) GetCompensationOutstanding() int64 {
	if m != nil {
		return m.CompensationOutstanding
	}
	return 0
}

func (m *ContractStat) GetFirstContractStart() time.Time {
	if m != nil {
		return m.FirstContractStart
	}
	return time.Time{}
}

func (m *ContractStat) GetLastContractEnd() time.Time {
	if m != nil {
		return m.LastContractEnd
	}
	return time.Time{}
}

func (m *ContractStat) GetRole() ContractStat_Role {
	if m != nil {
		return m.Role
	}
	return ContractStat_HOST
}

func (*ContractStat) XXX_MessageName() string {
	return "node.ContractStat"
}

type Contracts struct {
	Contracts            []*Contracts_Contract `protobuf:"bytes,1,rep,name=contracts,proto3" json:"contracts" pg:"contracts"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-" pg:"-"`
	XXX_unrecognized     []byte                `json:"-" pg:"-"`
	XXX_sizecache        int32                 `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Contracts proto.InternalMessageInfo

func (m *Contracts) GetContracts() []*Contracts_Contract {
	if m != nil {
		return m.Contracts
	}
	return nil
}

func (*Contracts) XXX_MessageName() string {
	return "node.Contracts"
}

type Contracts_Contract struct {
	ContractId              string                       `protobuf:"bytes,1,opt,name=contract_id,json=contractId,proto3" json:"contract_id" pg:"contract_id"`
	HostId                  string                       `protobuf:"bytes,2,opt,name=host_id,json=hostId,proto3" json:"host_id" pg:"host_id"`
	RenterId                string                       `protobuf:"bytes,3,opt,name=renter_id,json=renterId,proto3" json:"renter_id" pg:"renter_id"`
	Status                  guard.Contract_ContractState `protobuf:"varint,4,opt,name=status,proto3,enum=guard.Contract_ContractState" json:"status" pg:"status"`
	StartTime               time.Time                    `protobuf:"bytes,5,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time" pg:"start_time"`
	EndTime                 time.Time                    `protobuf:"bytes,6,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time" pg:"end_time"`
	NextEscrowTime          time.Time                    `protobuf:"bytes,7,opt,name=next_escrow_time,json=nextEscrowTime,proto3,stdtime" json:"next_escrow_time" pg:"next_escrow_time"`
	CompensationPaid        int64                        `protobuf:"varint,8,opt,name=compensation_paid,json=compensationPaid,proto3" json:"compensation_paid" pg:"compensation_paid"`
	CompensationOutstanding int64                        `protobuf:"varint,9,opt,name=compensation_outstanding,json=compensationOutstanding,proto3" json:"compensation_outstanding" pg:"compensation_outstanding"`
	UnitPrice               int64                        `protobuf:"varint,10,opt,name=unit_price,json=unitPrice,proto3" json:"unit_price" pg:"unit_price"`
	ShardSize               int64                        `protobuf:"varint,11,opt,name=shard_size,json=shardSize,proto3" json:"shard_size" pg:"shard_size"`
	ShardHash               string                       `protobuf:"bytes,12,opt,name=shard_hash,json=shardHash,proto3" json:"shard_hash" pg:"shard_hash"`
	FileHash                string                       `protobuf:"bytes,13,opt,name=file_hash,json=fileHash,proto3" json:"file_hash" pg:"file_hash"`
	LastModifyTime          time.Time                    `protobuf:"bytes,14,opt,name=last_modify_time,json=lastModifyTime,proto3,stdtime" json:"last_modify_time" pg:"last_modify_time"`
	XXX_NoUnkeyedLiteral    struct{}                     `json:"-" pg:"-"`
	XXX_unrecognized        []byte                       `json:"-" pg:"-"`
	XXX_sizecache           int32                        `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Contracts_Contract proto.InternalMessageInfo

func (m *Contracts_Contract) GetContractId() string {
	if m != nil {
		return m.ContractId
	}
	return ""
}

func (m *Contracts_Contract) GetHostId() string {
	if m != nil {
		return m.HostId
	}
	return ""
}

func (m *Contracts_Contract) GetRenterId() string {
	if m != nil {
		return m.RenterId
	}
	return ""
}

func (m *Contracts_Contract) GetStatus() guard.Contract_ContractState {
	if m != nil {
		return m.Status
	}
	return guard.Contract_DRAFT
}

func (m *Contracts_Contract) GetStartTime() time.Time {
	if m != nil {
		return m.StartTime
	}
	return time.Time{}
}

func (m *Contracts_Contract) GetEndTime() time.Time {
	if m != nil {
		return m.EndTime
	}
	return time.Time{}
}

func (m *Contracts_Contract) GetNextEscrowTime() time.Time {
	if m != nil {
		return m.NextEscrowTime
	}
	return time.Time{}
}

func (m *Contracts_Contract) GetCompensationPaid() int64 {
	if m != nil {
		return m.CompensationPaid
	}
	return 0
}

func (m *Contracts_Contract) GetCompensationOutstanding() int64 {
	if m != nil {
		return m.CompensationOutstanding
	}
	return 0
}

func (m *Contracts_Contract) GetUnitPrice() int64 {
	if m != nil {
		return m.UnitPrice
	}
	return 0
}

func (m *Contracts_Contract) GetShardSize() int64 {
	if m != nil {
		return m.ShardSize
	}
	return 0
}

func (m *Contracts_Contract) GetShardHash() string {
	if m != nil {
		return m.ShardHash
	}
	return ""
}

func (m *Contracts_Contract) GetFileHash() string {
	if m != nil {
		return m.FileHash
	}
	return ""
}

func (m *Contracts_Contract) GetLastModifyTime() time.Time {
	if m != nil {
		return m.LastModifyTime
	}
	return time.Time{}
}

func (*Contracts_Contract) XXX_MessageName() string {
	return "node.Contracts.Contract"
}

type BtfsScanTab struct {
	tableName            string           `pg:"btfs_scan,alias:t,discard_unknown_columns"`
	StorageVolumeLeft    float64          `protobuf:"fixed64,2,opt,name=storage_volume_left,json=storageVolumeLeft,proto3" json:"storage_volume_left,omitempty" pg:"storage_volume_left"`
	OnlineMinersNumber   uint32           `protobuf:"varint,3,opt,name=online_miners_number,json=onlineMinersNumber,proto3" json:"online_miners_number,omitempty" pg:"online_miners_number"`
	CountryDistribute    map[string]int32 `protobuf:"bytes,4,rep,name=country_distribute,json=countryDistribute,proto3" json:"country_distribute,omitempty" pg:"country_distribute" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	ScoreDistribute      map[string]int32 `protobuf:"bytes,5,rep,name=score_distribute,json=scoreDistribute,proto3" json:"score_distribute,omitempty" pg:"score_distribute" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	TimeCreated          time.Time        `protobuf:"bytes,6,opt,name=time_created,json=timeCreated,proto3,stdtime" json:"time_created" pg:"time_created"`
	StorageAlreadyUsed   float64          `protobuf:"fixed64,7,opt,name=storage_already_used,json=storageAlreadyUsed,proto3" json:"storage_already_used,omitempty" pg:"storage_already_used"`
	Price                float64          `protobuf:"fixed64,8,opt,name=price,proto3" json:"price,omitempty" pg:"price"`
	DateCreated          time.Time        `protobuf:"bytes,9,opt,name=date_created,json=dateCreated,proto3,stdtime" json:"date_created" pg:"date_created"`
	NewRank              string           `protobuf:"bytes,10,opt,name=new_rank,json=newRank,proto3" json:"new_rank,omitempty" pg:"new_rank"`
	TotalRank            string           `protobuf:"bytes,11,opt,name=total_rank,json=totalRank,proto3" json:"total_rank,omitempty" pg:"total_rank"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-" pg:"-"`
	XXX_unrecognized     []byte           `json:"-" pg:"-"`
	XXX_sizecache        int32            `json:"-" pg:"-"`
}

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

var xxx_messageInfo_BtfsScanTab proto.InternalMessageInfo

func (m *BtfsScanTab) GettableName() string {
	if m != nil {
		return m.tableName
	}
	return ""
}

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

func (m *BtfsScanTab) GetOnlineMinersNumber() uint32 {
	if m != nil {
		return m.OnlineMinersNumber
	}
	return 0
}

func (m *BtfsScanTab) GetCountryDistribute() map[string]int32 {
	if m != nil {
		return m.CountryDistribute
	}
	return nil
}

func (m *BtfsScanTab) GetScoreDistribute() map[string]int32 {
	if m != nil {
		return m.ScoreDistribute
	}
	return nil
}

func (m *BtfsScanTab) GetTimeCreated() time.Time {
	if m != nil {
		return m.TimeCreated
	}
	return time.Time{}
}

func (m *BtfsScanTab) GetStorageAlreadyUsed() float64 {
	if m != nil {
		return m.StorageAlreadyUsed
	}
	return 0
}

func (m *BtfsScanTab) GetPrice() float64 {
	if m != nil {
		return m.Price
	}
	return 0
}

func (m *BtfsScanTab) GetDateCreated() time.Time {
	if m != nil {
		return m.DateCreated
	}
	return time.Time{}
}

func (m *BtfsScanTab) GetNewRank() string {
	if m != nil {
		return m.NewRank
	}
	return ""
}

func (m *BtfsScanTab) GetTotalRank() string {
	if m != nil {
		return m.TotalRank
	}
	return ""
}

func (*BtfsScanTab) XXX_MessageName() string {
	return "node.BtfsScanTab"
}

type ScoreHistoryTab struct {
	tableName            string    `pg:"score_history,alias:t,discard_unknown_columns"`
	NodeId               string    `protobuf:"bytes,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty" pg:"node_id"`
	StorageVolumeCap     uint64    `protobuf:"varint,3,opt,name=storage_volume_cap,json=storageVolumeCap,proto3" json:"storage_volume_cap,omitempty" pg:"storage_volume_cap"`
	StorageVolumeLeft    uint64    `protobuf:"varint,4,opt,name=storage_volume_left,json=storageVolumeLeft,proto3" json:"storage_volume_left,omitempty" pg:"storage_volume_left"`
	Score                uint32    `protobuf:"varint,5,opt,name=score,proto3" json:"score,omitempty" pg:"score"`
	DateCreated          time.Time `protobuf:"bytes,6,opt,name=date_created,json=dateCreated,proto3,stdtime" json:"date_created" pg:"date_created"`
	TimeCreated          time.Time `protobuf:"bytes,7,opt,name=time_created,json=timeCreated,proto3,stdtime" json:"time_created" pg:"time_created"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
	XXX_unrecognized     []byte    `json:"-" pg:"-"`
	XXX_sizecache        int32     `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ScoreHistoryTab proto.InternalMessageInfo

func (m *ScoreHistoryTab) GettableName() string {
	if m != nil {
		return m.tableName
	}
	return ""
}

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

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

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

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

func (m *ScoreHistoryTab) GetDateCreated() time.Time {
	if m != nil {
		return m.DateCreated
	}
	return time.Time{}
}

func (m *ScoreHistoryTab) GetTimeCreated() time.Time {
	if m != nil {
		return m.TimeCreated
	}
	return time.Time{}
}

func (*ScoreHistoryTab) XXX_MessageName() string {
	return "node.ScoreHistoryTab"
}

type AirdropRewardHistoryTab struct {
	tableName            string    `pg:"airdrop_reward_history,alias:t,discard_unknown_columns"`
	Type                 uint32    `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty" pg:"type"`
	NodeId               string    `protobuf:"bytes,3,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty" pg:"node_id"`
	Reward               uint64    `protobuf:"varint,4,opt,name=reward,proto3" json:"reward,omitempty" pg:"reward"`
	IsSuspect            bool      `protobuf:"varint,5,opt,name=is_suspect,json=isSuspect,proto3" json:"is_suspect,omitempty" pg:"is_suspect"`
	Weight               uint32    `protobuf:"varint,6,opt,name=weight,proto3" json:"weight,omitempty" pg:"weight"`
	Stake                uint32    `protobuf:"varint,7,opt,name=stake,proto3" json:"stake,omitempty" pg:"stake"`
	DateCreated          time.Time `protobuf:"bytes,8,opt,name=date_created,json=dateCreated,proto3,stdtime" json:"date_created" pg:"date_created"`
	TimeCreated          time.Time `protobuf:"bytes,9,opt,name=time_created,json=timeCreated,proto3,stdtime" json:"time_created" pg:"time_created"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
	XXX_unrecognized     []byte    `json:"-" pg:"-"`
	XXX_sizecache        int32     `json:"-" pg:"-"`
}

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

var xxx_messageInfo_AirdropRewardHistoryTab proto.InternalMessageInfo

func (m *AirdropRewardHistoryTab) GettableName() string {
	if m != nil {
		return m.tableName
	}
	return ""
}

func (m *AirdropRewardHistoryTab) GetType() uint32 {
	if m != nil {
		return m.Type
	}
	return 0
}

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

func (m *AirdropRewardHistoryTab) GetReward() uint64 {
	if m != nil {
		return m.Reward
	}
	return 0
}

func (m *AirdropRewardHistoryTab) GetIsSuspect() bool {
	if m != nil {
		return m.IsSuspect
	}
	return false
}

func (m *AirdropRewardHistoryTab) GetWeight() uint32 {
	if m != nil {
		return m.Weight
	}
	return 0
}

func (m *AirdropRewardHistoryTab) GetStake() uint32 {
	if m != nil {
		return m.Stake
	}
	return 0
}

func (m *AirdropRewardHistoryTab) GetDateCreated() time.Time {
	if m != nil {
		return m.DateCreated
	}
	return time.Time{}
}

func (m *AirdropRewardHistoryTab) GetTimeCreated() time.Time {
	if m != nil {
		return m.TimeCreated
	}
	return time.Time{}
}

func (*AirdropRewardHistoryTab) XXX_MessageName() string {
	return "node.AirdropRewardHistoryTab"
}
func init() {
	proto.RegisterEnum("node.NodeRole", NodeRole_name, NodeRole_value)
	golang_proto.RegisterEnum("node.NodeRole", NodeRole_name, NodeRole_value)
	proto.RegisterEnum("node.DiscoveryErrorCode", DiscoveryErrorCode_name, DiscoveryErrorCode_value)
	golang_proto.RegisterEnum("node.DiscoveryErrorCode", DiscoveryErrorCode_name, DiscoveryErrorCode_value)
	proto.RegisterEnum("node.ContractStat_Role", ContractStat_Role_name, ContractStat_Role_value)
	golang_proto.RegisterEnum("node.ContractStat_Role", ContractStat_Role_name, ContractStat_Role_value)
	proto.RegisterType((*PayLoadInfo)(nil), "node.PayLoadInfo")
	golang_proto.RegisterType((*PayLoadInfo)(nil), "node.PayLoadInfo")
	proto.RegisterType((*DiscoveryNode)(nil), "node.DiscoveryNode")
	golang_proto.RegisterType((*DiscoveryNode)(nil), "node.DiscoveryNode")
	proto.RegisterType((*DiscoveryTab)(nil), "node.DiscoveryTab")
	golang_proto.RegisterType((*DiscoveryTab)(nil), "node.DiscoveryTab")
	proto.RegisterType((*Node)(nil), "node.Node")
	golang_proto.RegisterType((*Node)(nil), "node.Node")
	proto.RegisterType((*Node_Settings)(nil), "node.Node.Settings")
	golang_proto.RegisterType((*Node_Settings)(nil), "node.Node.Settings")
	proto.RegisterType((*Node_Geo)(nil), "node.Node.Geo")
	golang_proto.RegisterType((*Node_Geo)(nil), "node.Node.Geo")
	proto.RegisterType((*Node_ExperimentalFlags)(nil), "node.Node.ExperimentalFlags")
	golang_proto.RegisterType((*Node_ExperimentalFlags)(nil), "node.Node.ExperimentalFlags")
	proto.RegisterType((*StorageStat)(nil), "node.StorageStat")
	golang_proto.RegisterType((*StorageStat)(nil), "node.StorageStat")
	proto.RegisterType((*StorageStat_HostStats)(nil), "node.StorageStat.HostStats")
	golang_proto.RegisterType((*StorageStat_HostStats)(nil), "node.StorageStat.HostStats")
	proto.RegisterType((*StorageStat_Host)(nil), "node.StorageStat.Host")
	golang_proto.RegisterType((*StorageStat_Host)(nil), "node.StorageStat.Host")
	proto.RegisterType((*StorageStat_Renter)(nil), "node.StorageStat.Renter")
	golang_proto.RegisterType((*StorageStat_Renter)(nil), "node.StorageStat.Renter")
	proto.RegisterType((*ContractStat)(nil), "node.ContractStat")
	golang_proto.RegisterType((*ContractStat)(nil), "node.ContractStat")
	proto.RegisterType((*Contracts)(nil), "node.Contracts")
	golang_proto.RegisterType((*Contracts)(nil), "node.Contracts")
	proto.RegisterType((*Contracts_Contract)(nil), "node.Contracts.Contract")
	golang_proto.RegisterType((*Contracts_Contract)(nil), "node.Contracts.Contract")
	proto.RegisterType((*BtfsScanTab)(nil), "node.BtfsScanTab")
	golang_proto.RegisterType((*BtfsScanTab)(nil), "node.BtfsScanTab")
	proto.RegisterMapType((map[string]int32)(nil), "node.BtfsScanTab.CountryDistributeEntry")
	golang_proto.RegisterMapType((map[string]int32)(nil), "node.BtfsScanTab.CountryDistributeEntry")
	proto.RegisterMapType((map[string]int32)(nil), "node.BtfsScanTab.ScoreDistributeEntry")
	golang_proto.RegisterMapType((map[string]int32)(nil), "node.BtfsScanTab.ScoreDistributeEntry")
	proto.RegisterType((*ScoreHistoryTab)(nil), "node.ScoreHistoryTab")
	golang_proto.RegisterType((*ScoreHistoryTab)(nil), "node.ScoreHistoryTab")
	proto.RegisterType((*AirdropRewardHistoryTab)(nil), "node.AirdropRewardHistoryTab")
	golang_proto.RegisterType((*AirdropRewardHistoryTab)(nil), "node.AirdropRewardHistoryTab")
}

func init() { proto.RegisterFile("protos/node/node.proto", fileDescriptor_35f8e1f5ec2240a2) }
func init() { golang_proto.RegisterFile("protos/node/node.proto", fileDescriptor_35f8e1f5ec2240a2) }

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

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

func (m *PayLoadInfo) 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)
	}
	n1, err1 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.LastTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastTime):])
	if err1 != nil {
		return 0, err1
	}
	i -= n1
	i = encodeVarintNode(dAtA, i, uint64(n1))
	i--
	dAtA[i] = 0x22
	if len(m.DiscoveryNodes) > 0 {
		for iNdEx := len(m.DiscoveryNodes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DiscoveryNodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNode(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Node != nil {
		{
			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNode(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.NodeId) > 0 {
		i -= len(m.NodeId)
		copy(dAtA[i:], m.NodeId)
		i = encodeVarintNode(dAtA, i, uint64(len(m.NodeId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DiscoveryNode) 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.ErrCode != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.ErrCode))
		i--
		dAtA[i] = 0x18
	}
	if m.NodeConnectLatency != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.NodeConnectLatency))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ToNodeId) > 0 {
		i -= len(m.ToNodeId)
		copy(dAtA[i:], m.ToNodeId)
		i = encodeVarintNode(dAtA, i, uint64(len(m.ToNodeId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DiscoveryTab) 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.TimeCreated, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.TimeCreated):])
	if err3 != nil {
		return 0, err3
	}
	i -= n3
	i = encodeVarintNode(dAtA, i, uint64(n3))
	i--
	dAtA[i] = 0x3a
	if m.DiscoveryLabel != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.DiscoveryLabel))
		i--
		dAtA[i] = 0x30
	}
	if m.ErrCode != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.ErrCode))
		i--
		dAtA[i] = 0x28
	}
	if m.AvgConnectLatency != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.AvgConnectLatency))
		i--
		dAtA[i] = 0x20
	}
	if m.ConnectCnt != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.ConnectCnt))
		i--
		dAtA[i] = 0x18
	}
	if len(m.NodeId) > 0 {
		i -= len(m.NodeId)
		copy(dAtA[i:], m.NodeId)
		i = encodeVarintNode(dAtA, i, uint64(len(m.NodeId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.tableName) > 0 {
		i -= len(m.tableName)
		copy(dAtA[i:], m.tableName)
		i = encodeVarintNode(dAtA, i, uint64(len(m.tableName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Node) 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.Node_ExperimentalFlags.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintNode(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xda
	{
		size, err := m.Node_Geo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintNode(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xd2
	if len(m.HVal) > 0 {
		i -= len(m.HVal)
		copy(dAtA[i:], m.HVal)
		i = encodeVarintNode(dAtA, i, uint64(len(m.HVal)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xca
	}
	n6, err6 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.TimeCreated, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.TimeCreated):])
	if err6 != nil {
		return 0, err6
	}
	i -= n6
	i = encodeVarintNode(dAtA, i, uint64(n6))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xc2
	if m.PeersConnected != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.PeersConnected))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb8
	}
	if len(m.CpuInfo) > 0 {
		i -= len(m.CpuInfo)
		copy(dAtA[i:], m.CpuInfo)
		i = encodeVarintNode(dAtA, i, uint64(len(m.CpuInfo)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	if len(m.ArchType) > 0 {
		i -= len(m.ArchType)
		copy(dAtA[i:], m.ArchType)
		i = encodeVarintNode(dAtA, i, uint64(len(m.ArchType)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if len(m.OsType) > 0 {
		i -= len(m.OsType)
		copy(dAtA[i:], m.OsType)
		i = encodeVarintNode(dAtA, i, uint64(len(m.OsType)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if m.BlocksDown != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.BlocksDown))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	if m.BlocksUp != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.BlocksUp))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x88
	}
	if m.Reputation != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Reputation))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x81
	}
	{
		size, err := m.Node_Settings.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintNode(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	if m.BandwidthPriceDeal != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.BandwidthPriceDeal))
		i--
		dAtA[i] = 0x70
	}
	if m.StoragePriceDeal != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.StoragePriceDeal))
		i--
		dAtA[i] = 0x68
	}
	if m.TotalDownload != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.TotalDownload))
		i--
		dAtA[i] = 0x60
	}
	if m.TotalUpload != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.TotalUpload))
		i--
		dAtA[i] = 0x58
	}
	if m.Download != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.Download))
		i--
		dAtA[i] = 0x50
	}
	if m.Upload != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.Upload))
		i--
		dAtA[i] = 0x48
	}
	if m.CpuUsed != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.CpuUsed))))
		i--
		dAtA[i] = 0x41
	}
	if m.MemoryUsed != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.MemoryUsed))
		i--
		dAtA[i] = 0x38
	}
	if m.StorageVolumeCap != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.StorageVolumeCap))
		i--
		dAtA[i] = 0x30
	}
	if m.StorageUsed != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.StorageUsed))
		i--
		dAtA[i] = 0x28
	}
	if m.UpTime != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.UpTime))
		i--
		dAtA[i] = 0x20
	}
	if len(m.BtfsVersion) > 0 {
		i -= len(m.BtfsVersion)
		copy(dAtA[i:], m.BtfsVersion)
		i = encodeVarintNode(dAtA, i, uint64(len(m.BtfsVersion)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.NodeId) > 0 {
		i -= len(m.NodeId)
		copy(dAtA[i:], m.NodeId)
		i = encodeVarintNode(dAtA, i, uint64(len(m.NodeId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.tableName) > 0 {
		i -= len(m.tableName)
		copy(dAtA[i:], m.tableName)
		i = encodeVarintNode(dAtA, i, uint64(len(m.tableName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Node_Settings) 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.ChallengeCustomizedPricing {
		i--
		if m.ChallengeCustomizedPricing {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x70
	}
	if m.ChallengePriceCustomized != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.ChallengePriceCustomized))
		i--
		dAtA[i] = 0x68
	}
	if m.ChallengePriceDefault != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.ChallengePriceDefault))
		i--
		dAtA[i] = 0x60
	}
	if m.RepairCustomizedPricing {
		i--
		if m.RepairCustomizedPricing {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x58
	}
	if m.RepairPriceCustomized != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.RepairPriceCustomized))
		i--
		dAtA[i] = 0x50
	}
	if m.RepairPriceDefault != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.RepairPriceDefault))
		i--
		dAtA[i] = 0x48
	}
	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 = encodeVarintNode(dAtA, i, uint64(j8))
		i--
		dAtA[i] = 0x42
	}
	if m.CustomizedPricing {
		i--
		if m.CustomizedPricing {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.StoragePriceDefault != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.StoragePriceDefault))
		i--
		dAtA[i] = 0x30
	}
	if m.CollateralStake != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.CollateralStake))
		i--
		dAtA[i] = 0x28
	}
	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 = encodeVarintNode(dAtA, i, uint64(m.StorageTimeMin))
		i--
		dAtA[i] = 0x18
	}
	if m.BandwidthPriceAsk != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.BandwidthPriceAsk))
		i--
		dAtA[i] = 0x10
	}
	if m.StoragePriceAsk != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.StoragePriceAsk))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Node_Geo) 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.Longitude != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Longitude))))
		i--
		dAtA[i] = 0x25
	}
	if m.Latitude != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Latitude))))
		i--
		dAtA[i] = 0x1d
	}
	if len(m.Region) > 0 {
		i -= len(m.Region)
		copy(dAtA[i:], m.Region)
		i = encodeVarintNode(dAtA, i, uint64(len(m.Region)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.CountryShort) > 0 {
		i -= len(m.CountryShort)
		copy(dAtA[i:], m.CountryShort)
		i = encodeVarintNode(dAtA, i, uint64(len(m.CountryShort)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Node_ExperimentalFlags) 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.ChallengeHostEnabled {
		i--
		if m.ChallengeHostEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	if m.RepairHostEnabled {
		i--
		if m.RepairHostEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x88
	}
	if m.GraphsyncEnabled {
		i--
		if m.GraphsyncEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if m.DisableAutoUpdate {
		i--
		if m.DisableAutoUpdate {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x78
	}
	if m.UrlStoreEnabled {
		i--
		if m.UrlStoreEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x70
	}
	if m.StrategicProviding {
		i--
		if m.StrategicProviding {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if m.StorageHostEnabled {
		i--
		if m.StorageHostEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	if m.StorageClientEnabled {
		i--
		if m.StorageClientEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x58
	}
	if m.ShardingEnabled {
		i--
		if m.ShardingEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.RemoveOnUnpin {
		i--
		if m.RemoveOnUnpin {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x48
	}
	if m.Quic {
		i--
		if m.Quic {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.PreferTls {
		i--
		if m.PreferTls {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.P2PHttpProxy {
		i--
		if m.P2PHttpProxy {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.Libp2PStreamMounting {
		i--
		if m.Libp2PStreamMounting {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.HostsSyncMode) > 0 {
		i -= len(m.HostsSyncMode)
		copy(dAtA[i:], m.HostsSyncMode)
		i = encodeVarintNode(dAtA, i, uint64(len(m.HostsSyncMode)))
		i--
		dAtA[i] = 0x22
	}
	if m.HostsSyncEnabled {
		i--
		if m.HostsSyncEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.FilestoreEnabled {
		i--
		if m.FilestoreEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Analytics {
		i--
		if m.Analytics {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *StorageStat) 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.RenterStats.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintNode(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.HostStats.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintNode(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *StorageStat_HostStats) 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)
	}
	n12, err12 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.LastUpdated, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastUpdated):])
	if err12 != nil {
		return 0, err12
	}
	i -= n12
	i = encodeVarintNode(dAtA, i, uint64(n12))
	i--
	dAtA[i] = 0x7a
	if m.DownloadSpeedWeight != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.DownloadSpeedWeight))))
		i--
		dAtA[i] = 0x75
	}
	if m.UploadSpeedWeight != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UploadSpeedWeight))))
		i--
		dAtA[i] = 0x6d
	}
	if m.SpeedWeight != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.SpeedWeight))))
		i--
		dAtA[i] = 0x65
	}
	if m.VersionWeight != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.VersionWeight))))
		i--
		dAtA[i] = 0x5d
	}
	if m.AgeWeight != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.AgeWeight))))
		i--
		dAtA[i] = 0x55
	}
	if m.UptimeWeight != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UptimeWeight))))
		i--
		dAtA[i] = 0x4d
	}
	if m.DownloadSpeedScore != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.DownloadSpeedScore))))
		i--
		dAtA[i] = 0x45
	}
	if m.UploadSpeedScore != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UploadSpeedScore))))
		i--
		dAtA[i] = 0x3d
	}
	if m.SpeedScore != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.SpeedScore))))
		i--
		dAtA[i] = 0x35
	}
	if m.VersionScore != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.VersionScore))))
		i--
		dAtA[i] = 0x2d
	}
	if m.AgeScore != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.AgeScore))))
		i--
		dAtA[i] = 0x25
	}
	if m.UptimeScore != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UptimeScore))))
		i--
		dAtA[i] = 0x1d
	}
	if m.Score != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Score))))
		i--
		dAtA[i] = 0x15
	}
	if m.Uptime != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Uptime))))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

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

func (m *StorageStat_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)
	}
	{
		size, err := m.StorageStat_HostStats.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintNode(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if m.StorageDiskAvailable != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.StorageDiskAvailable))
		i--
		dAtA[i] = 0x28
	}
	if m.StorageDiskTotal != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.StorageDiskTotal))
		i--
		dAtA[i] = 0x20
	}
	if m.StorageCap != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.StorageCap))
		i--
		dAtA[i] = 0x18
	}
	if m.StorageUsed != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.StorageUsed))
		i--
		dAtA[i] = 0x10
	}
	if m.Online {
		i--
		if m.Online {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *StorageStat_Renter) 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.Reserved) > 0 {
		i -= len(m.Reserved)
		copy(dAtA[i:], m.Reserved)
		i = encodeVarintNode(dAtA, i, uint64(len(m.Reserved)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ContractStat) 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 = encodeVarintNode(dAtA, i, uint64(m.Role))
		i--
		dAtA[i] = 0x30
	}
	n14, err14 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.LastContractEnd, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastContractEnd):])
	if err14 != nil {
		return 0, err14
	}
	i -= n14
	i = encodeVarintNode(dAtA, i, uint64(n14))
	i--
	dAtA[i] = 0x2a
	n15, err15 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.FirstContractStart, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.FirstContractStart):])
	if err15 != nil {
		return 0, err15
	}
	i -= n15
	i = encodeVarintNode(dAtA, i, uint64(n15))
	i--
	dAtA[i] = 0x22
	if m.CompensationOutstanding != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.CompensationOutstanding))
		i--
		dAtA[i] = 0x18
	}
	if m.CompensationPaid != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.CompensationPaid))
		i--
		dAtA[i] = 0x10
	}
	if m.ActiveContractNum != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.ActiveContractNum))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Contracts) 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.Contracts) > 0 {
		for iNdEx := len(m.Contracts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Contracts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNode(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Contracts_Contract) 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)
	}
	n16, err16 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.LastModifyTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastModifyTime):])
	if err16 != nil {
		return 0, err16
	}
	i -= n16
	i = encodeVarintNode(dAtA, i, uint64(n16))
	i--
	dAtA[i] = 0x72
	if len(m.FileHash) > 0 {
		i -= len(m.FileHash)
		copy(dAtA[i:], m.FileHash)
		i = encodeVarintNode(dAtA, i, uint64(len(m.FileHash)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.ShardHash) > 0 {
		i -= len(m.ShardHash)
		copy(dAtA[i:], m.ShardHash)
		i = encodeVarintNode(dAtA, i, uint64(len(m.ShardHash)))
		i--
		dAtA[i] = 0x62
	}
	if m.ShardSize != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.ShardSize))
		i--
		dAtA[i] = 0x58
	}
	if m.UnitPrice != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.UnitPrice))
		i--
		dAtA[i] = 0x50
	}
	if m.CompensationOutstanding != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.CompensationOutstanding))
		i--
		dAtA[i] = 0x48
	}
	if m.CompensationPaid != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.CompensationPaid))
		i--
		dAtA[i] = 0x40
	}
	n17, err17 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.NextEscrowTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.NextEscrowTime):])
	if err17 != nil {
		return 0, err17
	}
	i -= n17
	i = encodeVarintNode(dAtA, i, uint64(n17))
	i--
	dAtA[i] = 0x3a
	n18, err18 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.EndTime):])
	if err18 != nil {
		return 0, err18
	}
	i -= n18
	i = encodeVarintNode(dAtA, i, uint64(n18))
	i--
	dAtA[i] = 0x32
	n19, err19 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.StartTime):])
	if err19 != nil {
		return 0, err19
	}
	i -= n19
	i = encodeVarintNode(dAtA, i, uint64(n19))
	i--
	dAtA[i] = 0x2a
	if m.Status != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x20
	}
	if len(m.RenterId) > 0 {
		i -= len(m.RenterId)
		copy(dAtA[i:], m.RenterId)
		i = encodeVarintNode(dAtA, i, uint64(len(m.RenterId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.HostId) > 0 {
		i -= len(m.HostId)
		copy(dAtA[i:], m.HostId)
		i = encodeVarintNode(dAtA, i, uint64(len(m.HostId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContractId) > 0 {
		i -= len(m.ContractId)
		copy(dAtA[i:], m.ContractId)
		i = encodeVarintNode(dAtA, i, uint64(len(m.ContractId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *BtfsScanTab) 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.TotalRank) > 0 {
		i -= len(m.TotalRank)
		copy(dAtA[i:], m.TotalRank)
		i = encodeVarintNode(dAtA, i, uint64(len(m.TotalRank)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.NewRank) > 0 {
		i -= len(m.NewRank)
		copy(dAtA[i:], m.NewRank)
		i = encodeVarintNode(dAtA, i, uint64(len(m.NewRank)))
		i--
		dAtA[i] = 0x52
	}
	n20, err20 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.DateCreated, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.DateCreated):])
	if err20 != nil {
		return 0, err20
	}
	i -= n20
	i = encodeVarintNode(dAtA, i, uint64(n20))
	i--
	dAtA[i] = 0x4a
	if m.Price != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Price))))
		i--
		dAtA[i] = 0x41
	}
	if m.StorageAlreadyUsed != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.StorageAlreadyUsed))))
		i--
		dAtA[i] = 0x39
	}
	n21, err21 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.TimeCreated, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.TimeCreated):])
	if err21 != nil {
		return 0, err21
	}
	i -= n21
	i = encodeVarintNode(dAtA, i, uint64(n21))
	i--
	dAtA[i] = 0x32
	if len(m.ScoreDistribute) > 0 {
		for k := range m.ScoreDistribute {
			v := m.ScoreDistribute[k]
			baseI := i
			i = encodeVarintNode(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintNode(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintNode(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.CountryDistribute) > 0 {
		for k := range m.CountryDistribute {
			v := m.CountryDistribute[k]
			baseI := i
			i = encodeVarintNode(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintNode(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintNode(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.OnlineMinersNumber != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.OnlineMinersNumber))
		i--
		dAtA[i] = 0x18
	}
	if m.StorageVolumeLeft != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.StorageVolumeLeft))))
		i--
		dAtA[i] = 0x11
	}
	if len(m.tableName) > 0 {
		i -= len(m.tableName)
		copy(dAtA[i:], m.tableName)
		i = encodeVarintNode(dAtA, i, uint64(len(m.tableName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ScoreHistoryTab) 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)
	}
	n22, err22 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.TimeCreated, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.TimeCreated):])
	if err22 != nil {
		return 0, err22
	}
	i -= n22
	i = encodeVarintNode(dAtA, i, uint64(n22))
	i--
	dAtA[i] = 0x3a
	n23, err23 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.DateCreated, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.DateCreated):])
	if err23 != nil {
		return 0, err23
	}
	i -= n23
	i = encodeVarintNode(dAtA, i, uint64(n23))
	i--
	dAtA[i] = 0x32
	if m.Score != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.Score))
		i--
		dAtA[i] = 0x28
	}
	if m.StorageVolumeLeft != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.StorageVolumeLeft))
		i--
		dAtA[i] = 0x20
	}
	if m.StorageVolumeCap != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.StorageVolumeCap))
		i--
		dAtA[i] = 0x18
	}
	if len(m.NodeId) > 0 {
		i -= len(m.NodeId)
		copy(dAtA[i:], m.NodeId)
		i = encodeVarintNode(dAtA, i, uint64(len(m.NodeId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.tableName) > 0 {
		i -= len(m.tableName)
		copy(dAtA[i:], m.tableName)
		i = encodeVarintNode(dAtA, i, uint64(len(m.tableName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AirdropRewardHistoryTab) 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)
	}
	n24, err24 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.TimeCreated, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.TimeCreated):])
	if err24 != nil {
		return 0, err24
	}
	i -= n24
	i = encodeVarintNode(dAtA, i, uint64(n24))
	i--
	dAtA[i] = 0x4a
	n25, err25 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.DateCreated, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.DateCreated):])
	if err25 != nil {
		return 0, err25
	}
	i -= n25
	i = encodeVarintNode(dAtA, i, uint64(n25))
	i--
	dAtA[i] = 0x42
	if m.Stake != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.Stake))
		i--
		dAtA[i] = 0x38
	}
	if m.Weight != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.Weight))
		i--
		dAtA[i] = 0x30
	}
	if m.IsSuspect {
		i--
		if m.IsSuspect {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Reward != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.Reward))
		i--
		dAtA[i] = 0x20
	}
	if len(m.NodeId) > 0 {
		i -= len(m.NodeId)
		copy(dAtA[i:], m.NodeId)
		i = encodeVarintNode(dAtA, i, uint64(len(m.NodeId)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Type != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.tableName) > 0 {
		i -= len(m.tableName)
		copy(dAtA[i:], m.tableName)
		i = encodeVarintNode(dAtA, i, uint64(len(m.tableName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintNode(dAtA []byte, offset int, v uint64) int {
	offset -= sovNode(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedPayLoadInfo(r randyNode, easy bool) *PayLoadInfo {
	this := &PayLoadInfo{}
	this.NodeId = string(randStringNode(r))
	if r.Intn(5) != 0 {
		this.Node = NewPopulatedNode(r, easy)
	}
	if r.Intn(5) != 0 {
		v1 := r.Intn(5)
		this.DiscoveryNodes = make([]*DiscoveryNode, v1)
		for i := 0; i < v1; i++ {
			this.DiscoveryNodes[i] = NewPopulatedDiscoveryNode(r, easy)
		}
	}
	v2 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.LastTime = *v2
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 5)
	}
	return this
}

func NewPopulatedDiscoveryNode(r randyNode, easy bool) *DiscoveryNode {
	this := &DiscoveryNode{}
	this.ToNodeId = string(randStringNode(r))
	this.NodeConnectLatency = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.NodeConnectLatency *= -1
	}
	this.ErrCode = DiscoveryErrorCode([]int32{0, 1, 2, 3, 10}[r.Intn(5)])
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 4)
	}
	return this
}

func NewPopulatedDiscoveryTab(r randyNode, easy bool) *DiscoveryTab {
	this := &DiscoveryTab{}
	this.tableName = string(randStringNode(r))
	this.NodeId = string(randStringNode(r))
	this.ConnectCnt = uint32(r.Uint32())
	this.AvgConnectLatency = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.AvgConnectLatency *= -1
	}
	this.ErrCode = DiscoveryErrorCode([]int32{0, 1, 2, 3, 10}[r.Intn(5)])
	this.DiscoveryLabel = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.DiscoveryLabel *= -1
	}
	v3 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.TimeCreated = *v3
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 8)
	}
	return this
}

func NewPopulatedNode(r randyNode, easy bool) *Node {
	this := &Node{}
	this.tableName = string(randStringNode(r))
	this.NodeId = string(randStringNode(r))
	this.BtfsVersion = string(randStringNode(r))
	this.UpTime = uint64(uint64(r.Uint32()))
	this.StorageUsed = uint64(uint64(r.Uint32()))
	this.StorageVolumeCap = uint64(uint64(r.Uint32()))
	this.MemoryUsed = uint64(uint64(r.Uint32()))
	this.CpuUsed = float64(r.Float64())
	if r.Intn(2) == 0 {
		this.CpuUsed *= -1
	}
	this.Upload = uint64(uint64(r.Uint32()))
	this.Download = uint64(uint64(r.Uint32()))
	this.TotalUpload = uint64(uint64(r.Uint32()))
	this.TotalDownload = uint64(uint64(r.Uint32()))
	this.StoragePriceDeal = uint64(uint64(r.Uint32()))
	this.BandwidthPriceDeal = uint64(uint64(r.Uint32()))
	v4 := NewPopulatedNode_Settings(r, easy)
	this.Node_Settings = *v4
	this.Reputation = float64(r.Float64())
	if r.Intn(2) == 0 {
		this.Reputation *= -1
	}
	this.BlocksUp = uint64(uint64(r.Uint32()))
	this.BlocksDown = uint64(uint64(r.Uint32()))
	this.OsType = string(randStringNode(r))
	this.ArchType = string(randStringNode(r))
	this.CpuInfo = string(randStringNode(r))
	this.PeersConnected = uint64(uint64(r.Uint32()))
	v5 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.TimeCreated = *v5
	this.HVal = string(randStringNode(r))
	v6 := NewPopulatedNode_Geo(r, easy)
	this.Node_Geo = *v6
	v7 := NewPopulatedNode_ExperimentalFlags(r, easy)
	this.Node_ExperimentalFlags = *v7
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 28)
	}
	return this
}

func NewPopulatedNode_Settings(r randyNode, easy bool) *Node_Settings {
	this := &Node_Settings{}
	this.StoragePriceAsk = uint64(uint64(r.Uint32()))
	this.BandwidthPriceAsk = uint64(uint64(r.Uint32()))
	this.StorageTimeMin = uint64(uint64(r.Uint32()))
	this.BandwidthLimit = float64(r.Float64())
	if r.Intn(2) == 0 {
		this.BandwidthLimit *= -1
	}
	this.CollateralStake = uint64(uint64(r.Uint32()))
	this.StoragePriceDefault = uint64(uint64(r.Uint32()))
	this.CustomizedPricing = bool(bool(r.Intn(2) == 0))
	v8 := r.Intn(10)
	this.Roles = make([]NodeRole, v8)
	for i := 0; i < v8; i++ {
		this.Roles[i] = NodeRole([]int32{0, 1, 2, 3, 4, 5, 6, 20}[r.Intn(8)])
	}
	this.RepairPriceDefault = uint64(uint64(r.Uint32()))
	this.RepairPriceCustomized = uint64(uint64(r.Uint32()))
	this.RepairCustomizedPricing = bool(bool(r.Intn(2) == 0))
	this.ChallengePriceDefault = uint64(uint64(r.Uint32()))
	this.ChallengePriceCustomized = uint64(uint64(r.Uint32()))
	this.ChallengeCustomizedPricing = bool(bool(r.Intn(2) == 0))
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 15)
	}
	return this
}

func NewPopulatedNode_Geo(r randyNode, easy bool) *Node_Geo {
	this := &Node_Geo{}
	this.CountryShort = string(randStringNode(r))
	this.Region = string(randStringNode(r))
	this.Latitude = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Latitude *= -1
	}
	this.Longitude = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Longitude *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 5)
	}
	return this
}

func NewPopulatedNode_ExperimentalFlags(r randyNode, easy bool) *Node_ExperimentalFlags {
	this := &Node_ExperimentalFlags{}
	this.Analytics = bool(bool(r.Intn(2) == 0))
	this.FilestoreEnabled = bool(bool(r.Intn(2) == 0))
	this.HostsSyncEnabled = bool(bool(r.Intn(2) == 0))
	this.HostsSyncMode = string(randStringNode(r))
	this.Libp2PStreamMounting = bool(bool(r.Intn(2) == 0))
	this.P2PHttpProxy = bool(bool(r.Intn(2) == 0))
	this.PreferTls = bool(bool(r.Intn(2) == 0))
	this.Quic = bool(bool(r.Intn(2) == 0))
	this.RemoveOnUnpin = bool(bool(r.Intn(2) == 0))
	this.ShardingEnabled = bool(bool(r.Intn(2) == 0))
	this.StorageClientEnabled = bool(bool(r.Intn(2) == 0))
	this.StorageHostEnabled = bool(bool(r.Intn(2) == 0))
	this.StrategicProviding = bool(bool(r.Intn(2) == 0))
	this.UrlStoreEnabled = bool(bool(r.Intn(2) == 0))
	this.DisableAutoUpdate = bool(bool(r.Intn(2) == 0))
	this.GraphsyncEnabled = bool(bool(r.Intn(2) == 0))
	this.RepairHostEnabled = bool(bool(r.Intn(2) == 0))
	this.ChallengeHostEnabled = bool(bool(r.Intn(2) == 0))
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 19)
	}
	return this
}

func NewPopulatedStorageStat(r randyNode, easy bool) *StorageStat {
	this := &StorageStat{}
	v9 := NewPopulatedStorageStat_Host(r, easy)
	this.HostStats = *v9
	v10 := NewPopulatedStorageStat_Renter(r, easy)
	this.RenterStats = *v10
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 3)
	}
	return this
}

func NewPopulatedStorageStat_HostStats(r randyNode, easy bool) *StorageStat_HostStats {
	this := &StorageStat_HostStats{}
	this.Uptime = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Uptime *= -1
	}
	this.Score = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Score *= -1
	}
	this.UptimeScore = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.UptimeScore *= -1
	}
	this.AgeScore = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.AgeScore *= -1
	}
	this.VersionScore = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.VersionScore *= -1
	}
	this.SpeedScore = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.SpeedScore *= -1
	}
	this.UploadSpeedScore = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.UploadSpeedScore *= -1
	}
	this.DownloadSpeedScore = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.DownloadSpeedScore *= -1
	}
	this.UptimeWeight = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.UptimeWeight *= -1
	}
	this.AgeWeight = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.AgeWeight *= -1
	}
	this.VersionWeight = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.VersionWeight *= -1
	}
	this.SpeedWeight = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.SpeedWeight *= -1
	}
	this.UploadSpeedWeight = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.UploadSpeedWeight *= -1
	}
	this.DownloadSpeedWeight = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.DownloadSpeedWeight *= -1
	}
	v11 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.LastUpdated = *v11
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 16)
	}
	return this
}

func NewPopulatedStorageStat_Host(r randyNode, easy bool) *StorageStat_Host {
	this := &StorageStat_Host{}
	this.Online = bool(bool(r.Intn(2) == 0))
	this.StorageUsed = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.StorageUsed *= -1
	}
	this.StorageCap = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.StorageCap *= -1
	}
	this.StorageDiskTotal = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.StorageDiskTotal *= -1
	}
	this.StorageDiskAvailable = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.StorageDiskAvailable *= -1
	}
	v12 := NewPopulatedStorageStat_HostStats(r, easy)
	this.StorageStat_HostStats = *v12
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 7)
	}
	return this
}

func NewPopulatedStorageStat_Renter(r randyNode, easy bool) *StorageStat_Renter {
	this := &StorageStat_Renter{}
	this.Reserved = string(randStringNode(r))
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 2)
	}
	return this
}

func NewPopulatedContractStat(r randyNode, easy bool) *ContractStat {
	this := &ContractStat{}
	this.ActiveContractNum = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.ActiveContractNum *= -1
	}
	this.CompensationPaid = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.CompensationPaid *= -1
	}
	this.CompensationOutstanding = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.CompensationOutstanding *= -1
	}
	v13 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.FirstContractStart = *v13
	v14 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.LastContractEnd = *v14
	this.Role = ContractStat_Role([]int32{0, 1, 2}[r.Intn(3)])
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 7)
	}
	return this
}

func NewPopulatedContracts(r randyNode, easy bool) *Contracts {
	this := &Contracts{}
	if r.Intn(5) != 0 {
		v15 := r.Intn(5)
		this.Contracts = make([]*Contracts_Contract, v15)
		for i := 0; i < v15; i++ {
			this.Contracts[i] = NewPopulatedContracts_Contract(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 2)
	}
	return this
}

func NewPopulatedContracts_Contract(r randyNode, easy bool) *Contracts_Contract {
	this := &Contracts_Contract{}
	this.ContractId = string(randStringNode(r))
	this.HostId = string(randStringNode(r))
	this.RenterId = string(randStringNode(r))
	this.Status = guard.Contract_ContractState([]int32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}[r.Intn(13)])
	v16 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.StartTime = *v16
	v17 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.EndTime = *v17
	v18 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.NextEscrowTime = *v18
	this.CompensationPaid = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.CompensationPaid *= -1
	}
	this.CompensationOutstanding = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.CompensationOutstanding *= -1
	}
	this.UnitPrice = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.UnitPrice *= -1
	}
	this.ShardSize = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.ShardSize *= -1
	}
	this.ShardHash = string(randStringNode(r))
	this.FileHash = string(randStringNode(r))
	v19 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.LastModifyTime = *v19
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 15)
	}
	return this
}

func NewPopulatedBtfsScanTab(r randyNode, easy bool) *BtfsScanTab {
	this := &BtfsScanTab{}
	this.tableName = string(randStringNode(r))
	this.StorageVolumeLeft = float64(r.Float64())
	if r.Intn(2) == 0 {
		this.StorageVolumeLeft *= -1
	}
	this.OnlineMinersNumber = uint32(r.Uint32())
	if r.Intn(5) != 0 {
		v20 := r.Intn(10)
		this.CountryDistribute = make(map[string]int32)
		for i := 0; i < v20; i++ {
			v21 := randStringNode(r)
			this.CountryDistribute[v21] = int32(r.Int31())
			if r.Intn(2) == 0 {
				this.CountryDistribute[v21] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v22 := r.Intn(10)
		this.ScoreDistribute = make(map[string]int32)
		for i := 0; i < v22; i++ {
			v23 := randStringNode(r)
			this.ScoreDistribute[v23] = int32(r.Int31())
			if r.Intn(2) == 0 {
				this.ScoreDistribute[v23] *= -1
			}
		}
	}
	v24 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.TimeCreated = *v24
	this.StorageAlreadyUsed = float64(r.Float64())
	if r.Intn(2) == 0 {
		this.StorageAlreadyUsed *= -1
	}
	this.Price = float64(r.Float64())
	if r.Intn(2) == 0 {
		this.Price *= -1
	}
	v25 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.DateCreated = *v25
	this.NewRank = string(randStringNode(r))
	this.TotalRank = string(randStringNode(r))
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 12)
	}
	return this
}

func NewPopulatedScoreHistoryTab(r randyNode, easy bool) *ScoreHistoryTab {
	this := &ScoreHistoryTab{}
	this.tableName = string(randStringNode(r))
	this.NodeId = string(randStringNode(r))
	this.StorageVolumeCap = uint64(uint64(r.Uint32()))
	this.StorageVolumeLeft = uint64(uint64(r.Uint32()))
	this.Score = uint32(r.Uint32())
	v26 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.DateCreated = *v26
	v27 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.TimeCreated = *v27
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 8)
	}
	return this
}

func NewPopulatedAirdropRewardHistoryTab(r randyNode, easy bool) *AirdropRewardHistoryTab {
	this := &AirdropRewardHistoryTab{}
	this.tableName = string(randStringNode(r))
	this.Type = uint32(r.Uint32())
	this.NodeId = string(randStringNode(r))
	this.Reward = uint64(uint64(r.Uint32()))
	this.IsSuspect = bool(bool(r.Intn(2) == 0))
	this.Weight = uint32(r.Uint32())
	this.Stake = uint32(r.Uint32())
	v28 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.DateCreated = *v28
	v29 := github_com_tron_us_protobuf_types.NewPopulatedStdTime(r, easy)
	this.TimeCreated = *v29
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedNode(r, 10)
	}
	return this
}

type randyNode interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneNode(r randyNode) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringNode(r randyNode) string {
	v30 := r.Intn(100)
	tmps := make([]rune, v30)
	for i := 0; i < v30; i++ {
		tmps[i] = randUTF8RuneNode(r)
	}
	return string(tmps)
}
func randUnrecognizedNode(r randyNode, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldNode(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldNode(dAtA []byte, r randyNode, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateNode(dAtA, uint64(key))
		v31 := r.Int63()
		if r.Intn(2) == 0 {
			v31 *= -1
		}
		dAtA = encodeVarintPopulateNode(dAtA, uint64(v31))
	case 1:
		dAtA = encodeVarintPopulateNode(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateNode(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateNode(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateNode(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateNode(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *PayLoadInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NodeId)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.Node != nil {
		l = m.Node.Size()
		n += 1 + l + sovNode(uint64(l))
	}
	if len(m.DiscoveryNodes) > 0 {
		for _, e := range m.DiscoveryNodes {
			l = e.Size()
			n += 1 + l + sovNode(uint64(l))
		}
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastTime)
	n += 1 + l + sovNode(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DiscoveryNode) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ToNodeId)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.NodeConnectLatency != 0 {
		n += 1 + sovNode(uint64(m.NodeConnectLatency))
	}
	if m.ErrCode != 0 {
		n += 1 + sovNode(uint64(m.ErrCode))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DiscoveryTab) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.tableName)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.NodeId)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.ConnectCnt != 0 {
		n += 1 + sovNode(uint64(m.ConnectCnt))
	}
	if m.AvgConnectLatency != 0 {
		n += 1 + sovNode(uint64(m.AvgConnectLatency))
	}
	if m.ErrCode != 0 {
		n += 1 + sovNode(uint64(m.ErrCode))
	}
	if m.DiscoveryLabel != 0 {
		n += 1 + sovNode(uint64(m.DiscoveryLabel))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.TimeCreated)
	n += 1 + l + sovNode(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Node) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.tableName)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.NodeId)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.BtfsVersion)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.UpTime != 0 {
		n += 1 + sovNode(uint64(m.UpTime))
	}
	if m.StorageUsed != 0 {
		n += 1 + sovNode(uint64(m.StorageUsed))
	}
	if m.StorageVolumeCap != 0 {
		n += 1 + sovNode(uint64(m.StorageVolumeCap))
	}
	if m.MemoryUsed != 0 {
		n += 1 + sovNode(uint64(m.MemoryUsed))
	}
	if m.CpuUsed != 0 {
		n += 9
	}
	if m.Upload != 0 {
		n += 1 + sovNode(uint64(m.Upload))
	}
	if m.Download != 0 {
		n += 1 + sovNode(uint64(m.Download))
	}
	if m.TotalUpload != 0 {
		n += 1 + sovNode(uint64(m.TotalUpload))
	}
	if m.TotalDownload != 0 {
		n += 1 + sovNode(uint64(m.TotalDownload))
	}
	if m.StoragePriceDeal != 0 {
		n += 1 + sovNode(uint64(m.StoragePriceDeal))
	}
	if m.BandwidthPriceDeal != 0 {
		n += 1 + sovNode(uint64(m.BandwidthPriceDeal))
	}
	l = m.Node_Settings.Size()
	n += 1 + l + sovNode(uint64(l))
	if m.Reputation != 0 {
		n += 10
	}
	if m.BlocksUp != 0 {
		n += 2 + sovNode(uint64(m.BlocksUp))
	}
	if m.BlocksDown != 0 {
		n += 2 + sovNode(uint64(m.BlocksDown))
	}
	l = len(m.OsType)
	if l > 0 {
		n += 2 + l + sovNode(uint64(l))
	}
	l = len(m.ArchType)
	if l > 0 {
		n += 2 + l + sovNode(uint64(l))
	}
	l = len(m.CpuInfo)
	if l > 0 {
		n += 2 + l + sovNode(uint64(l))
	}
	if m.PeersConnected != 0 {
		n += 2 + sovNode(uint64(m.PeersConnected))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.TimeCreated)
	n += 2 + l + sovNode(uint64(l))
	l = len(m.HVal)
	if l > 0 {
		n += 2 + l + sovNode(uint64(l))
	}
	l = m.Node_Geo.Size()
	n += 2 + l + sovNode(uint64(l))
	l = m.Node_ExperimentalFlags.Size()
	n += 2 + l + sovNode(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Node_Settings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StoragePriceAsk != 0 {
		n += 1 + sovNode(uint64(m.StoragePriceAsk))
	}
	if m.BandwidthPriceAsk != 0 {
		n += 1 + sovNode(uint64(m.BandwidthPriceAsk))
	}
	if m.StorageTimeMin != 0 {
		n += 1 + sovNode(uint64(m.StorageTimeMin))
	}
	if m.BandwidthLimit != 0 {
		n += 9
	}
	if m.CollateralStake != 0 {
		n += 1 + sovNode(uint64(m.CollateralStake))
	}
	if m.StoragePriceDefault != 0 {
		n += 1 + sovNode(uint64(m.StoragePriceDefault))
	}
	if m.CustomizedPricing {
		n += 2
	}
	if len(m.Roles) > 0 {
		l = 0
		for _, e := range m.Roles {
			l += sovNode(uint64(e))
		}
		n += 1 + sovNode(uint64(l)) + l
	}
	if m.RepairPriceDefault != 0 {
		n += 1 + sovNode(uint64(m.RepairPriceDefault))
	}
	if m.RepairPriceCustomized != 0 {
		n += 1 + sovNode(uint64(m.RepairPriceCustomized))
	}
	if m.RepairCustomizedPricing {
		n += 2
	}
	if m.ChallengePriceDefault != 0 {
		n += 1 + sovNode(uint64(m.ChallengePriceDefault))
	}
	if m.ChallengePriceCustomized != 0 {
		n += 1 + sovNode(uint64(m.ChallengePriceCustomized))
	}
	if m.ChallengeCustomizedPricing {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Node_Geo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.CountryShort)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.Region)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.Latitude != 0 {
		n += 5
	}
	if m.Longitude != 0 {
		n += 5
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Node_ExperimentalFlags) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Analytics {
		n += 2
	}
	if m.FilestoreEnabled {
		n += 2
	}
	if m.HostsSyncEnabled {
		n += 2
	}
	l = len(m.HostsSyncMode)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.Libp2PStreamMounting {
		n += 2
	}
	if m.P2PHttpProxy {
		n += 2
	}
	if m.PreferTls {
		n += 2
	}
	if m.Quic {
		n += 2
	}
	if m.RemoveOnUnpin {
		n += 2
	}
	if m.ShardingEnabled {
		n += 2
	}
	if m.StorageClientEnabled {
		n += 2
	}
	if m.StorageHostEnabled {
		n += 2
	}
	if m.StrategicProviding {
		n += 2
	}
	if m.UrlStoreEnabled {
		n += 2
	}
	if m.DisableAutoUpdate {
		n += 2
	}
	if m.GraphsyncEnabled {
		n += 3
	}
	if m.RepairHostEnabled {
		n += 3
	}
	if m.ChallengeHostEnabled {
		n += 3
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StorageStat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.HostStats.Size()
	n += 1 + l + sovNode(uint64(l))
	l = m.RenterStats.Size()
	n += 1 + l + sovNode(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StorageStat_HostStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uptime != 0 {
		n += 5
	}
	if m.Score != 0 {
		n += 5
	}
	if m.UptimeScore != 0 {
		n += 5
	}
	if m.AgeScore != 0 {
		n += 5
	}
	if m.VersionScore != 0 {
		n += 5
	}
	if m.SpeedScore != 0 {
		n += 5
	}
	if m.UploadSpeedScore != 0 {
		n += 5
	}
	if m.DownloadSpeedScore != 0 {
		n += 5
	}
	if m.UptimeWeight != 0 {
		n += 5
	}
	if m.AgeWeight != 0 {
		n += 5
	}
	if m.VersionWeight != 0 {
		n += 5
	}
	if m.SpeedWeight != 0 {
		n += 5
	}
	if m.UploadSpeedWeight != 0 {
		n += 5
	}
	if m.DownloadSpeedWeight != 0 {
		n += 5
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastUpdated)
	n += 1 + l + sovNode(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StorageStat_Host) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Online {
		n += 2
	}
	if m.StorageUsed != 0 {
		n += 1 + sovNode(uint64(m.StorageUsed))
	}
	if m.StorageCap != 0 {
		n += 1 + sovNode(uint64(m.StorageCap))
	}
	if m.StorageDiskTotal != 0 {
		n += 1 + sovNode(uint64(m.StorageDiskTotal))
	}
	if m.StorageDiskAvailable != 0 {
		n += 1 + sovNode(uint64(m.StorageDiskAvailable))
	}
	l = m.StorageStat_HostStats.Size()
	n += 1 + l + sovNode(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *ContractStat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ActiveContractNum != 0 {
		n += 1 + sovNode(uint64(m.ActiveContractNum))
	}
	if m.CompensationPaid != 0 {
		n += 1 + sovNode(uint64(m.CompensationPaid))
	}
	if m.CompensationOutstanding != 0 {
		n += 1 + sovNode(uint64(m.CompensationOutstanding))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.FirstContractStart)
	n += 1 + l + sovNode(uint64(l))
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastContractEnd)
	n += 1 + l + sovNode(uint64(l))
	if m.Role != 0 {
		n += 1 + sovNode(uint64(m.Role))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *Contracts_Contract) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractId)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.HostId)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.RenterId)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovNode(uint64(m.Status))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.StartTime)
	n += 1 + l + sovNode(uint64(l))
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.EndTime)
	n += 1 + l + sovNode(uint64(l))
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.NextEscrowTime)
	n += 1 + l + sovNode(uint64(l))
	if m.CompensationPaid != 0 {
		n += 1 + sovNode(uint64(m.CompensationPaid))
	}
	if m.CompensationOutstanding != 0 {
		n += 1 + sovNode(uint64(m.CompensationOutstanding))
	}
	if m.UnitPrice != 0 {
		n += 1 + sovNode(uint64(m.UnitPrice))
	}
	if m.ShardSize != 0 {
		n += 1 + sovNode(uint64(m.ShardSize))
	}
	l = len(m.ShardHash)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.FileHash)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastModifyTime)
	n += 1 + l + sovNode(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BtfsScanTab) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.tableName)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.StorageVolumeLeft != 0 {
		n += 9
	}
	if m.OnlineMinersNumber != 0 {
		n += 1 + sovNode(uint64(m.OnlineMinersNumber))
	}
	if len(m.CountryDistribute) > 0 {
		for k, v := range m.CountryDistribute {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovNode(uint64(len(k))) + 1 + sovNode(uint64(v))
			n += mapEntrySize + 1 + sovNode(uint64(mapEntrySize))
		}
	}
	if len(m.ScoreDistribute) > 0 {
		for k, v := range m.ScoreDistribute {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovNode(uint64(len(k))) + 1 + sovNode(uint64(v))
			n += mapEntrySize + 1 + sovNode(uint64(mapEntrySize))
		}
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.TimeCreated)
	n += 1 + l + sovNode(uint64(l))
	if m.StorageAlreadyUsed != 0 {
		n += 9
	}
	if m.Price != 0 {
		n += 9
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.DateCreated)
	n += 1 + l + sovNode(uint64(l))
	l = len(m.NewRank)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.TotalRank)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ScoreHistoryTab) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.tableName)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.NodeId)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.StorageVolumeCap != 0 {
		n += 1 + sovNode(uint64(m.StorageVolumeCap))
	}
	if m.StorageVolumeLeft != 0 {
		n += 1 + sovNode(uint64(m.StorageVolumeLeft))
	}
	if m.Score != 0 {
		n += 1 + sovNode(uint64(m.Score))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.DateCreated)
	n += 1 + l + sovNode(uint64(l))
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.TimeCreated)
	n += 1 + l + sovNode(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AirdropRewardHistoryTab) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.tableName)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovNode(uint64(m.Type))
	}
	l = len(m.NodeId)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.Reward != 0 {
		n += 1 + sovNode(uint64(m.Reward))
	}
	if m.IsSuspect {
		n += 2
	}
	if m.Weight != 0 {
		n += 1 + sovNode(uint64(m.Weight))
	}
	if m.Stake != 0 {
		n += 1 + sovNode(uint64(m.Stake))
	}
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.DateCreated)
	n += 1 + l + sovNode(uint64(l))
	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.TimeCreated)
	n += 1 + l + sovNode(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovNode(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozNode(x uint64) (n int) {
	return sovNode(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *PayLoadInfo) 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 ErrIntOverflowNode
			}
			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: PayLoadInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PayLoadInfo: 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 ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			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 Node", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Node == nil {
				m.Node = &Node{}
			}
			if err := m.Node.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DiscoveryNodes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DiscoveryNodes = append(m.DiscoveryNodes, &DiscoveryNode{})
			if err := m.DiscoveryNodes[len(m.DiscoveryNodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.LastTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *DiscoveryNode) 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 ErrIntOverflowNode
			}
			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: DiscoveryNode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DiscoveryNode: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToNodeId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToNodeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeConnectLatency", wireType)
			}
			m.NodeConnectLatency = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeConnectLatency |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrCode", wireType)
			}
			m.ErrCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ErrCode |= DiscoveryErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *DiscoveryTab) 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 ErrIntOverflowNode
			}
			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: DiscoveryTab: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DiscoveryTab: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field tableName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.tableName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectCnt", wireType)
			}
			m.ConnectCnt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConnectCnt |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvgConnectLatency", wireType)
			}
			m.AvgConnectLatency = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AvgConnectLatency |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrCode", wireType)
			}
			m.ErrCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ErrCode |= DiscoveryErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DiscoveryLabel", wireType)
			}
			m.DiscoveryLabel = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DiscoveryLabel |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeCreated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.TimeCreated, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *Node) 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 ErrIntOverflowNode
			}
			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: Node: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Node: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field tableName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.tableName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BtfsVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpTime", wireType)
			}
			m.UpTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpTime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageUsed", wireType)
			}
			m.StorageUsed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageUsed |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageVolumeCap", wireType)
			}
			m.StorageVolumeCap = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageVolumeCap |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemoryUsed", wireType)
			}
			m.MemoryUsed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MemoryUsed |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpuUsed", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.CpuUsed = float64(math.Float64frombits(v))
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Upload", wireType)
			}
			m.Upload = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Upload |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Download", wireType)
			}
			m.Download = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Download |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalUpload", wireType)
			}
			m.TotalUpload = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalUpload |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalDownload", wireType)
			}
			m.TotalDownload = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalDownload |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoragePriceDeal", wireType)
			}
			m.StoragePriceDeal = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoragePriceDeal |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BandwidthPriceDeal", wireType)
			}
			m.BandwidthPriceDeal = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BandwidthPriceDeal |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node_Settings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Node_Settings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Reputation = float64(math.Float64frombits(v))
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlocksUp", wireType)
			}
			m.BlocksUp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlocksUp |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlocksDown", wireType)
			}
			m.BlocksDown = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlocksDown |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OsType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OsType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArchType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ArchType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpuInfo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CpuInfo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 23:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeersConnected", wireType)
			}
			m.PeersConnected = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeersConnected |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeCreated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.TimeCreated, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HVal", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HVal = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node_Geo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Node_Geo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 27:
			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 ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Node_ExperimentalFlags.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *Node_Settings) 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 ErrIntOverflowNode
			}
			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: Settings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Settings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoragePriceAsk |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BandwidthPriceAsk |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageTimeMin |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 != 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 ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CollateralStake |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoragePriceDefault", wireType)
			}
			m.StoragePriceDefault = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoragePriceDefault |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomizedPricing", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CustomizedPricing = bool(v != 0)
		case 8:
			if wireType == 0 {
				var v NodeRole
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowNode
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= 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 ErrIntOverflowNode
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthNode
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthNode
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Roles) == 0 {
					m.Roles = make([]NodeRole, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v NodeRole
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= 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)
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepairPriceDefault", wireType)
			}
			m.RepairPriceDefault = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RepairPriceDefault |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepairPriceCustomized", wireType)
			}
			m.RepairPriceCustomized = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RepairPriceCustomized |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepairCustomizedPricing", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RepairCustomizedPricing = bool(v != 0)
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChallengePriceDefault", wireType)
			}
			m.ChallengePriceDefault = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChallengePriceDefault |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChallengePriceCustomized", wireType)
			}
			m.ChallengePriceCustomized = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChallengePriceCustomized |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChallengeCustomizedPricing", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ChallengeCustomizedPricing = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *Node_Geo) 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 ErrIntOverflowNode
			}
			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: Geo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Geo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CountryShort = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Region = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Latitude", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Latitude = float32(math.Float32frombits(v))
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Longitude", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Longitude = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *Node_ExperimentalFlags) 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 ErrIntOverflowNode
			}
			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: ExperimentalFlags: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExperimentalFlags: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Analytics", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Analytics = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FilestoreEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.FilestoreEnabled = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostsSyncEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HostsSyncEnabled = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostsSyncMode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostsSyncMode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Libp2PStreamMounting", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Libp2PStreamMounting = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field P2PHttpProxy", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.P2PHttpProxy = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreferTls", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PreferTls = bool(v != 0)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quic", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Quic = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoveOnUnpin", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RemoveOnUnpin = bool(v != 0)
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardingEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ShardingEnabled = bool(v != 0)
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageClientEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.StorageClientEnabled = bool(v != 0)
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageHostEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.StorageHostEnabled = bool(v != 0)
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StrategicProviding", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.StrategicProviding = bool(v != 0)
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UrlStoreEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UrlStoreEnabled = bool(v != 0)
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisableAutoUpdate", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisableAutoUpdate = bool(v != 0)
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GraphsyncEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.GraphsyncEnabled = bool(v != 0)
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepairHostEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RepairHostEnabled = bool(v != 0)
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChallengeHostEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ChallengeHostEnabled = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *StorageStat) 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 ErrIntOverflowNode
			}
			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: StorageStat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StorageStat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostStats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.HostStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RenterStats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RenterStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *StorageStat_HostStats) 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 ErrIntOverflowNode
			}
			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: HostStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			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 3:
			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 4:
			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 5:
			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 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpeedScore", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.SpeedScore = float32(math.Float32frombits(v))
		case 7:
			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 8:
			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 9:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field UptimeWeight", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.UptimeWeight = float32(math.Float32frombits(v))
		case 10:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgeWeight", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.AgeWeight = float32(math.Float32frombits(v))
		case 11:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field VersionWeight", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.VersionWeight = float32(math.Float32frombits(v))
		case 12:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpeedWeight", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.SpeedWeight = float32(math.Float32frombits(v))
		case 13:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field UploadSpeedWeight", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.UploadSpeedWeight = float32(math.Float32frombits(v))
		case 14:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownloadSpeedWeight", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.DownloadSpeedWeight = float32(math.Float32frombits(v))
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.LastUpdated, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *StorageStat_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 ErrIntOverflowNode
			}
			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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Online", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Online = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageUsed", wireType)
			}
			m.StorageUsed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageUsed |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageCap", wireType)
			}
			m.StorageCap = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageCap |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageDiskTotal", wireType)
			}
			m.StorageDiskTotal = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageDiskTotal |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageDiskAvailable", wireType)
			}
			m.StorageDiskAvailable = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageDiskAvailable |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			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 := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *StorageStat_Renter) 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 ErrIntOverflowNode
			}
			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: Renter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Renter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reserved", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reserved = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *ContractStat) 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 ErrIntOverflowNode
			}
			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: ContractStat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractStat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveContractNum", wireType)
			}
			m.ActiveContractNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActiveContractNum |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompensationPaid", wireType)
			}
			m.CompensationPaid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompensationPaid |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompensationOutstanding", wireType)
			}
			m.CompensationOutstanding = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompensationOutstanding |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstContractStart", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.FirstContractStart, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastContractEnd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.LastContractEnd, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Role |= ContractStat_Role(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *Contracts) 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 ErrIntOverflowNode
			}
			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: Contracts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Contracts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contracts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Contracts = append(m.Contracts, &Contracts_Contract{})
			if err := m.Contracts[len(m.Contracts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *Contracts_Contract) 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 ErrIntOverflowNode
			}
			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: Contract: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Contract: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RenterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RenterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= guard.Contract_ContractState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.EndTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextEscrowTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.NextEscrowTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompensationPaid", wireType)
			}
			m.CompensationPaid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompensationPaid |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompensationOutstanding", wireType)
			}
			m.CompensationOutstanding = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompensationOutstanding |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnitPrice", wireType)
			}
			m.UnitPrice = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnitPrice |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardSize", wireType)
			}
			m.ShardSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ShardSize |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ShardHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FileHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastModifyTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.LastModifyTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *BtfsScanTab) 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 ErrIntOverflowNode
			}
			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: BtfsScanTab: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BtfsScanTab: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field tableName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.tableName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageVolumeLeft", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.StorageVolumeLeft = float64(math.Float64frombits(v))
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OnlineMinersNumber", wireType)
			}
			m.OnlineMinersNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OnlineMinersNumber |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CountryDistribute", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CountryDistribute == nil {
				m.CountryDistribute = make(map[string]int32)
			}
			var mapkey string
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowNode
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthNode
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthNode
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipNode(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthNode
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.CountryDistribute[mapkey] = mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScoreDistribute", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScoreDistribute == nil {
				m.ScoreDistribute = make(map[string]int32)
			}
			var mapkey string
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowNode
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthNode
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthNode
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipNode(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthNode
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ScoreDistribute[mapkey] = mapvalue
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeCreated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.TimeCreated, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageAlreadyUsed", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.StorageAlreadyUsed = float64(math.Float64frombits(v))
		case 8:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Price = float64(math.Float64frombits(v))
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DateCreated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.DateCreated, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewRank", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NewRank = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalRank", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TotalRank = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *ScoreHistoryTab) 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 ErrIntOverflowNode
			}
			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: ScoreHistoryTab: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScoreHistoryTab: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field tableName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.tableName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageVolumeCap", wireType)
			}
			m.StorageVolumeCap = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageVolumeCap |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageVolumeLeft", wireType)
			}
			m.StorageVolumeLeft = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageVolumeLeft |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType)
			}
			m.Score = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Score |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DateCreated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.DateCreated, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeCreated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.TimeCreated, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 *AirdropRewardHistoryTab) 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 ErrIntOverflowNode
			}
			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: AirdropRewardHistoryTab: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AirdropRewardHistoryTab: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field tableName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.tableName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowNode
				}
				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 ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reward", wireType)
			}
			m.Reward = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Reward |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsSuspect", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsSuspect = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			m.Weight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Weight |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stake", wireType)
			}
			m.Stake = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Stake |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DateCreated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.DateCreated, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeCreated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.TimeCreated, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			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 skipNode(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, ErrIntOverflowNode
			}
			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, ErrIntOverflowNode
				}
				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, ErrIntOverflowNode
				}
				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, ErrInvalidLengthNode
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupNode
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthNode
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthNode        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowNode          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupNode = fmt.Errorf("proto: unexpected end of group")
)