storj/pkg/statdb/proto/statdb.pb.go

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

package statdb

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import context "golang.org/x/net/context"
import grpc "google.golang.org/grpc"

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

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

// CreateRequest is a request message for the Create rpc call
type CreateRequest struct {
	Node                 *Node      `protobuf:"bytes,1,opt,name=node" json:"node,omitempty"`
	Stats                *NodeStats `protobuf:"bytes,2,opt,name=stats" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *CreateRequest) Reset()         { *m = CreateRequest{} }
func (m *CreateRequest) String() string { return proto.CompactTextString(m) }
func (*CreateRequest) ProtoMessage()    {}
func (*CreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{0}
}
func (m *CreateRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateRequest.Unmarshal(m, b)
}
func (m *CreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateRequest.Marshal(b, m, deterministic)
}
func (dst *CreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateRequest.Merge(dst, src)
}
func (m *CreateRequest) XXX_Size() int {
	return xxx_messageInfo_CreateRequest.Size(m)
}
func (m *CreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateRequest proto.InternalMessageInfo

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

func (m *CreateRequest) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// CreateResponse is a response message for the Create rpc call
type CreateResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *CreateResponse) Reset()         { *m = CreateResponse{} }
func (m *CreateResponse) String() string { return proto.CompactTextString(m) }
func (*CreateResponse) ProtoMessage()    {}
func (*CreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{1}
}
func (m *CreateResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateResponse.Unmarshal(m, b)
}
func (m *CreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateResponse.Marshal(b, m, deterministic)
}
func (dst *CreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateResponse.Merge(dst, src)
}
func (m *CreateResponse) XXX_Size() int {
	return xxx_messageInfo_CreateResponse.Size(m)
}
func (m *CreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CreateResponse proto.InternalMessageInfo

func (m *CreateResponse) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// GetRequest is a request message for the Get rpc call
type GetRequest struct {
	NodeId               NodeID   `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3,customtype=NodeID" json:"node_id"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetRequest) Reset()         { *m = GetRequest{} }
func (m *GetRequest) String() string { return proto.CompactTextString(m) }
func (*GetRequest) ProtoMessage()    {}
func (*GetRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{2}
}
func (m *GetRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetRequest.Unmarshal(m, b)
}
func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetRequest.Marshal(b, m, deterministic)
}
func (dst *GetRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetRequest.Merge(dst, src)
}
func (m *GetRequest) XXX_Size() int {
	return xxx_messageInfo_GetRequest.Size(m)
}
func (m *GetRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetRequest proto.InternalMessageInfo

// GetResponse is a response message for the Get rpc call
type GetResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *GetResponse) Reset()         { *m = GetResponse{} }
func (m *GetResponse) String() string { return proto.CompactTextString(m) }
func (*GetResponse) ProtoMessage()    {}
func (*GetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{3}
}
func (m *GetResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetResponse.Unmarshal(m, b)
}
func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetResponse.Marshal(b, m, deterministic)
}
func (dst *GetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetResponse.Merge(dst, src)
}
func (m *GetResponse) XXX_Size() int {
	return xxx_messageInfo_GetResponse.Size(m)
}
func (m *GetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetResponse proto.InternalMessageInfo

func (m *GetResponse) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// FindInvalidNodesRequest is a request message for the FindInvalidNodes rpc call
type FindInvalidNodesRequest struct {
	NodeIds              []NodeID   `protobuf:"bytes,1,rep,name=node_ids,json=nodeIds,customtype=NodeID" json:"node_ids,omitempty"`
	MaxStats             *NodeStats `protobuf:"bytes,2,opt,name=max_stats,json=maxStats" json:"max_stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *FindInvalidNodesRequest) Reset()         { *m = FindInvalidNodesRequest{} }
func (m *FindInvalidNodesRequest) String() string { return proto.CompactTextString(m) }
func (*FindInvalidNodesRequest) ProtoMessage()    {}
func (*FindInvalidNodesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{4}
}
func (m *FindInvalidNodesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FindInvalidNodesRequest.Unmarshal(m, b)
}
func (m *FindInvalidNodesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FindInvalidNodesRequest.Marshal(b, m, deterministic)
}
func (dst *FindInvalidNodesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FindInvalidNodesRequest.Merge(dst, src)
}
func (m *FindInvalidNodesRequest) XXX_Size() int {
	return xxx_messageInfo_FindInvalidNodesRequest.Size(m)
}
func (m *FindInvalidNodesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FindInvalidNodesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FindInvalidNodesRequest proto.InternalMessageInfo

func (m *FindInvalidNodesRequest) GetMaxStats() *NodeStats {
	if m != nil {
		return m.MaxStats
	}
	return nil
}

// FindInvalidNodesResponse is a response message for the FindInvalidNodes rpc call
type FindInvalidNodesResponse struct {
	InvalidIds           []NodeID `protobuf:"bytes,1,rep,name=invalid_ids,json=invalidIds,customtype=NodeID" json:"invalid_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FindInvalidNodesResponse) Reset()         { *m = FindInvalidNodesResponse{} }
func (m *FindInvalidNodesResponse) String() string { return proto.CompactTextString(m) }
func (*FindInvalidNodesResponse) ProtoMessage()    {}
func (*FindInvalidNodesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{5}
}
func (m *FindInvalidNodesResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FindInvalidNodesResponse.Unmarshal(m, b)
}
func (m *FindInvalidNodesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FindInvalidNodesResponse.Marshal(b, m, deterministic)
}
func (dst *FindInvalidNodesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FindInvalidNodesResponse.Merge(dst, src)
}
func (m *FindInvalidNodesResponse) XXX_Size() int {
	return xxx_messageInfo_FindInvalidNodesResponse.Size(m)
}
func (m *FindInvalidNodesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_FindInvalidNodesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_FindInvalidNodesResponse proto.InternalMessageInfo

// UpdateRequest is a request message for the Update rpc call
type UpdateRequest struct {
	Node                 *Node    `protobuf:"bytes,1,opt,name=node" json:"node,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpdateRequest) Reset()         { *m = UpdateRequest{} }
func (m *UpdateRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateRequest) ProtoMessage()    {}
func (*UpdateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{6}
}
func (m *UpdateRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateRequest.Unmarshal(m, b)
}
func (m *UpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateRequest.Marshal(b, m, deterministic)
}
func (dst *UpdateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateRequest.Merge(dst, src)
}
func (m *UpdateRequest) XXX_Size() int {
	return xxx_messageInfo_UpdateRequest.Size(m)
}
func (m *UpdateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateRequest proto.InternalMessageInfo

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

// UpdateRequest is a response message for the Update rpc call
type UpdateResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *UpdateResponse) Reset()         { *m = UpdateResponse{} }
func (m *UpdateResponse) String() string { return proto.CompactTextString(m) }
func (*UpdateResponse) ProtoMessage()    {}
func (*UpdateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{7}
}
func (m *UpdateResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateResponse.Unmarshal(m, b)
}
func (m *UpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateResponse.Marshal(b, m, deterministic)
}
func (dst *UpdateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateResponse.Merge(dst, src)
}
func (m *UpdateResponse) XXX_Size() int {
	return xxx_messageInfo_UpdateResponse.Size(m)
}
func (m *UpdateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateResponse proto.InternalMessageInfo

func (m *UpdateResponse) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// UpdateUptimeRequest is a request message for the UpdateUptime rpc call
type UpdateUptimeRequest struct {
	Node                 *Node    `protobuf:"bytes,1,opt,name=node" json:"node,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpdateUptimeRequest) Reset()         { *m = UpdateUptimeRequest{} }
func (m *UpdateUptimeRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateUptimeRequest) ProtoMessage()    {}
func (*UpdateUptimeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{8}
}
func (m *UpdateUptimeRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateUptimeRequest.Unmarshal(m, b)
}
func (m *UpdateUptimeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateUptimeRequest.Marshal(b, m, deterministic)
}
func (dst *UpdateUptimeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateUptimeRequest.Merge(dst, src)
}
func (m *UpdateUptimeRequest) XXX_Size() int {
	return xxx_messageInfo_UpdateUptimeRequest.Size(m)
}
func (m *UpdateUptimeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateUptimeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateUptimeRequest proto.InternalMessageInfo

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

// UpdateUptimeResponse is a response message for the UpdateUptime rpc call
type UpdateUptimeResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *UpdateUptimeResponse) Reset()         { *m = UpdateUptimeResponse{} }
func (m *UpdateUptimeResponse) String() string { return proto.CompactTextString(m) }
func (*UpdateUptimeResponse) ProtoMessage()    {}
func (*UpdateUptimeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{9}
}
func (m *UpdateUptimeResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateUptimeResponse.Unmarshal(m, b)
}
func (m *UpdateUptimeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateUptimeResponse.Marshal(b, m, deterministic)
}
func (dst *UpdateUptimeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateUptimeResponse.Merge(dst, src)
}
func (m *UpdateUptimeResponse) XXX_Size() int {
	return xxx_messageInfo_UpdateUptimeResponse.Size(m)
}
func (m *UpdateUptimeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateUptimeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateUptimeResponse proto.InternalMessageInfo

func (m *UpdateUptimeResponse) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// UpdateAuditSuccessRequest is a request message for the UpdateAuditSuccess rpc call
type UpdateAuditSuccessRequest struct {
	Node                 *Node    `protobuf:"bytes,1,opt,name=node" json:"node,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpdateAuditSuccessRequest) Reset()         { *m = UpdateAuditSuccessRequest{} }
func (m *UpdateAuditSuccessRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateAuditSuccessRequest) ProtoMessage()    {}
func (*UpdateAuditSuccessRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{10}
}
func (m *UpdateAuditSuccessRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateAuditSuccessRequest.Unmarshal(m, b)
}
func (m *UpdateAuditSuccessRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateAuditSuccessRequest.Marshal(b, m, deterministic)
}
func (dst *UpdateAuditSuccessRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateAuditSuccessRequest.Merge(dst, src)
}
func (m *UpdateAuditSuccessRequest) XXX_Size() int {
	return xxx_messageInfo_UpdateAuditSuccessRequest.Size(m)
}
func (m *UpdateAuditSuccessRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateAuditSuccessRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateAuditSuccessRequest proto.InternalMessageInfo

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

// UpdateAuditSuccessResponse is a response message for the UpdateAuditSuccess rpc call
type UpdateAuditSuccessResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *UpdateAuditSuccessResponse) Reset()         { *m = UpdateAuditSuccessResponse{} }
func (m *UpdateAuditSuccessResponse) String() string { return proto.CompactTextString(m) }
func (*UpdateAuditSuccessResponse) ProtoMessage()    {}
func (*UpdateAuditSuccessResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{11}
}
func (m *UpdateAuditSuccessResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateAuditSuccessResponse.Unmarshal(m, b)
}
func (m *UpdateAuditSuccessResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateAuditSuccessResponse.Marshal(b, m, deterministic)
}
func (dst *UpdateAuditSuccessResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateAuditSuccessResponse.Merge(dst, src)
}
func (m *UpdateAuditSuccessResponse) XXX_Size() int {
	return xxx_messageInfo_UpdateAuditSuccessResponse.Size(m)
}
func (m *UpdateAuditSuccessResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateAuditSuccessResponse.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateAuditSuccessResponse proto.InternalMessageInfo

func (m *UpdateAuditSuccessResponse) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

// UpdateBatchRequest is a request message for the UpdateBatch rpc call
type UpdateBatchRequest struct {
	NodeList             []*Node  `protobuf:"bytes,1,rep,name=node_list,json=nodeList" json:"node_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpdateBatchRequest) Reset()         { *m = UpdateBatchRequest{} }
func (m *UpdateBatchRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateBatchRequest) ProtoMessage()    {}
func (*UpdateBatchRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{12}
}
func (m *UpdateBatchRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateBatchRequest.Unmarshal(m, b)
}
func (m *UpdateBatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateBatchRequest.Marshal(b, m, deterministic)
}
func (dst *UpdateBatchRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateBatchRequest.Merge(dst, src)
}
func (m *UpdateBatchRequest) XXX_Size() int {
	return xxx_messageInfo_UpdateBatchRequest.Size(m)
}
func (m *UpdateBatchRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateBatchRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateBatchRequest proto.InternalMessageInfo

func (m *UpdateBatchRequest) GetNodeList() []*Node {
	if m != nil {
		return m.NodeList
	}
	return nil
}

// UpdateBatchResponse is a response message for the UpdateBatch rpc call
type UpdateBatchResponse struct {
	StatsList            []*NodeStats `protobuf:"bytes,1,rep,name=stats_list,json=statsList" json:"stats_list,omitempty"`
	FailedNodes          []*Node      `protobuf:"bytes,2,rep,name=failed_nodes,json=failedNodes" json:"failed_nodes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *UpdateBatchResponse) Reset()         { *m = UpdateBatchResponse{} }
func (m *UpdateBatchResponse) String() string { return proto.CompactTextString(m) }
func (*UpdateBatchResponse) ProtoMessage()    {}
func (*UpdateBatchResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{13}
}
func (m *UpdateBatchResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateBatchResponse.Unmarshal(m, b)
}
func (m *UpdateBatchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateBatchResponse.Marshal(b, m, deterministic)
}
func (dst *UpdateBatchResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateBatchResponse.Merge(dst, src)
}
func (m *UpdateBatchResponse) XXX_Size() int {
	return xxx_messageInfo_UpdateBatchResponse.Size(m)
}
func (m *UpdateBatchResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateBatchResponse.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateBatchResponse proto.InternalMessageInfo

func (m *UpdateBatchResponse) GetStatsList() []*NodeStats {
	if m != nil {
		return m.StatsList
	}
	return nil
}

func (m *UpdateBatchResponse) GetFailedNodes() []*Node {
	if m != nil {
		return m.FailedNodes
	}
	return nil
}

// CreateEntryIfNotExistsRequest is a request message for the CreateEntryIfNotExists rpc call
type CreateEntryIfNotExistsRequest struct {
	Node                 *Node    `protobuf:"bytes,1,opt,name=node" json:"node,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateEntryIfNotExistsRequest) Reset()         { *m = CreateEntryIfNotExistsRequest{} }
func (m *CreateEntryIfNotExistsRequest) String() string { return proto.CompactTextString(m) }
func (*CreateEntryIfNotExistsRequest) ProtoMessage()    {}
func (*CreateEntryIfNotExistsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{14}
}
func (m *CreateEntryIfNotExistsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateEntryIfNotExistsRequest.Unmarshal(m, b)
}
func (m *CreateEntryIfNotExistsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateEntryIfNotExistsRequest.Marshal(b, m, deterministic)
}
func (dst *CreateEntryIfNotExistsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateEntryIfNotExistsRequest.Merge(dst, src)
}
func (m *CreateEntryIfNotExistsRequest) XXX_Size() int {
	return xxx_messageInfo_CreateEntryIfNotExistsRequest.Size(m)
}
func (m *CreateEntryIfNotExistsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateEntryIfNotExistsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateEntryIfNotExistsRequest proto.InternalMessageInfo

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

// CreateEntryIfNotExistsResponse is a response message for the CreateEntryIfNotExists rpc call
type CreateEntryIfNotExistsResponse struct {
	Stats                *NodeStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *CreateEntryIfNotExistsResponse) Reset()         { *m = CreateEntryIfNotExistsResponse{} }
func (m *CreateEntryIfNotExistsResponse) String() string { return proto.CompactTextString(m) }
func (*CreateEntryIfNotExistsResponse) ProtoMessage()    {}
func (*CreateEntryIfNotExistsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_statdb_c60cfd63f3ff5762, []int{15}
}
func (m *CreateEntryIfNotExistsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateEntryIfNotExistsResponse.Unmarshal(m, b)
}
func (m *CreateEntryIfNotExistsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateEntryIfNotExistsResponse.Marshal(b, m, deterministic)
}
func (dst *CreateEntryIfNotExistsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateEntryIfNotExistsResponse.Merge(dst, src)
}
func (m *CreateEntryIfNotExistsResponse) XXX_Size() int {
	return xxx_messageInfo_CreateEntryIfNotExistsResponse.Size(m)
}
func (m *CreateEntryIfNotExistsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateEntryIfNotExistsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CreateEntryIfNotExistsResponse proto.InternalMessageInfo

func (m *CreateEntryIfNotExistsResponse) GetStats() *NodeStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

func init() {
	proto.RegisterType((*CreateRequest)(nil), "statdb.CreateRequest")
	proto.RegisterType((*CreateResponse)(nil), "statdb.CreateResponse")
	proto.RegisterType((*GetRequest)(nil), "statdb.GetRequest")
	proto.RegisterType((*GetResponse)(nil), "statdb.GetResponse")
	proto.RegisterType((*FindInvalidNodesRequest)(nil), "statdb.FindInvalidNodesRequest")
	proto.RegisterType((*FindInvalidNodesResponse)(nil), "statdb.FindInvalidNodesResponse")
	proto.RegisterType((*UpdateRequest)(nil), "statdb.UpdateRequest")
	proto.RegisterType((*UpdateResponse)(nil), "statdb.UpdateResponse")
	proto.RegisterType((*UpdateUptimeRequest)(nil), "statdb.UpdateUptimeRequest")
	proto.RegisterType((*UpdateUptimeResponse)(nil), "statdb.UpdateUptimeResponse")
	proto.RegisterType((*UpdateAuditSuccessRequest)(nil), "statdb.UpdateAuditSuccessRequest")
	proto.RegisterType((*UpdateAuditSuccessResponse)(nil), "statdb.UpdateAuditSuccessResponse")
	proto.RegisterType((*UpdateBatchRequest)(nil), "statdb.UpdateBatchRequest")
	proto.RegisterType((*UpdateBatchResponse)(nil), "statdb.UpdateBatchResponse")
	proto.RegisterType((*CreateEntryIfNotExistsRequest)(nil), "statdb.CreateEntryIfNotExistsRequest")
	proto.RegisterType((*CreateEntryIfNotExistsResponse)(nil), "statdb.CreateEntryIfNotExistsResponse")
}

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

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

// Client API for StatDB service

type StatDBClient interface {
	// Create a db entry for the provided storagenode ID
	Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error)
	// Get uses a storagenode ID to get that storagenode's stats
	Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
	// FindInvalidNodes gets a subset of storagenodes that fail to meet minimum reputation args
	FindInvalidNodes(ctx context.Context, in *FindInvalidNodesRequest, opts ...grpc.CallOption) (*FindInvalidNodesResponse, error)
	// Update updates all stats for a single storagenode
	Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error)
	// UpdateUptime updates uptime stats for a single storagenode
	UpdateUptime(ctx context.Context, in *UpdateUptimeRequest, opts ...grpc.CallOption) (*UpdateUptimeResponse, error)
	// UpdateAuditSuccess updates audit success stats for a single storagenode
	UpdateAuditSuccess(ctx context.Context, in *UpdateAuditSuccessRequest, opts ...grpc.CallOption) (*UpdateAuditSuccessResponse, error)
	// UpdateBatch updates storagenode stats for multiple farmers at a time
	UpdateBatch(ctx context.Context, in *UpdateBatchRequest, opts ...grpc.CallOption) (*UpdateBatchResponse, error)
	// CreateEntryIfNotExists creates a db entry if it didn't exist
	CreateEntryIfNotExists(ctx context.Context, in *CreateEntryIfNotExistsRequest, opts ...grpc.CallOption) (*CreateEntryIfNotExistsResponse, error)
}

type statDBClient struct {
	cc *grpc.ClientConn
}

func NewStatDBClient(cc *grpc.ClientConn) StatDBClient {
	return &statDBClient{cc}
}

func (c *statDBClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) {
	out := new(CreateResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/Create", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
	out := new(GetResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/Get", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) FindInvalidNodes(ctx context.Context, in *FindInvalidNodesRequest, opts ...grpc.CallOption) (*FindInvalidNodesResponse, error) {
	out := new(FindInvalidNodesResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/FindInvalidNodes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) {
	out := new(UpdateResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/Update", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) UpdateUptime(ctx context.Context, in *UpdateUptimeRequest, opts ...grpc.CallOption) (*UpdateUptimeResponse, error) {
	out := new(UpdateUptimeResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/UpdateUptime", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) UpdateAuditSuccess(ctx context.Context, in *UpdateAuditSuccessRequest, opts ...grpc.CallOption) (*UpdateAuditSuccessResponse, error) {
	out := new(UpdateAuditSuccessResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/UpdateAuditSuccess", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) UpdateBatch(ctx context.Context, in *UpdateBatchRequest, opts ...grpc.CallOption) (*UpdateBatchResponse, error) {
	out := new(UpdateBatchResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/UpdateBatch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *statDBClient) CreateEntryIfNotExists(ctx context.Context, in *CreateEntryIfNotExistsRequest, opts ...grpc.CallOption) (*CreateEntryIfNotExistsResponse, error) {
	out := new(CreateEntryIfNotExistsResponse)
	err := c.cc.Invoke(ctx, "/statdb.StatDB/CreateEntryIfNotExists", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for StatDB service

type StatDBServer interface {
	// Create a db entry for the provided storagenode ID
	Create(context.Context, *CreateRequest) (*CreateResponse, error)
	// Get uses a storagenode ID to get that storagenode's stats
	Get(context.Context, *GetRequest) (*GetResponse, error)
	// FindInvalidNodes gets a subset of storagenodes that fail to meet minimum reputation args
	FindInvalidNodes(context.Context, *FindInvalidNodesRequest) (*FindInvalidNodesResponse, error)
	// Update updates all stats for a single storagenode
	Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
	// UpdateUptime updates uptime stats for a single storagenode
	UpdateUptime(context.Context, *UpdateUptimeRequest) (*UpdateUptimeResponse, error)
	// UpdateAuditSuccess updates audit success stats for a single storagenode
	UpdateAuditSuccess(context.Context, *UpdateAuditSuccessRequest) (*UpdateAuditSuccessResponse, error)
	// UpdateBatch updates storagenode stats for multiple farmers at a time
	UpdateBatch(context.Context, *UpdateBatchRequest) (*UpdateBatchResponse, error)
	// CreateEntryIfNotExists creates a db entry if it didn't exist
	CreateEntryIfNotExists(context.Context, *CreateEntryIfNotExistsRequest) (*CreateEntryIfNotExistsResponse, error)
}

func RegisterStatDBServer(s *grpc.Server, srv StatDBServer) {
	s.RegisterService(&_StatDB_serviceDesc, srv)
}

func _StatDB_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).Create(ctx, req.(*CreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/Get",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).Get(ctx, req.(*GetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_FindInvalidNodes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FindInvalidNodesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).FindInvalidNodes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/FindInvalidNodes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).FindInvalidNodes(ctx, req.(*FindInvalidNodesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).Update(ctx, req.(*UpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_UpdateUptime_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateUptimeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).UpdateUptime(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/UpdateUptime",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).UpdateUptime(ctx, req.(*UpdateUptimeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_UpdateAuditSuccess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateAuditSuccessRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).UpdateAuditSuccess(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/UpdateAuditSuccess",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).UpdateAuditSuccess(ctx, req.(*UpdateAuditSuccessRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_UpdateBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateBatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).UpdateBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/UpdateBatch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).UpdateBatch(ctx, req.(*UpdateBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StatDB_CreateEntryIfNotExists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateEntryIfNotExistsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StatDBServer).CreateEntryIfNotExists(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/statdb.StatDB/CreateEntryIfNotExists",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StatDBServer).CreateEntryIfNotExists(ctx, req.(*CreateEntryIfNotExistsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _StatDB_serviceDesc = grpc.ServiceDesc{
	ServiceName: "statdb.StatDB",
	HandlerType: (*StatDBServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _StatDB_Create_Handler,
		},
		{
			MethodName: "Get",
			Handler:    _StatDB_Get_Handler,
		},
		{
			MethodName: "FindInvalidNodes",
			Handler:    _StatDB_FindInvalidNodes_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _StatDB_Update_Handler,
		},
		{
			MethodName: "UpdateUptime",
			Handler:    _StatDB_UpdateUptime_Handler,
		},
		{
			MethodName: "UpdateAuditSuccess",
			Handler:    _StatDB_UpdateAuditSuccess_Handler,
		},
		{
			MethodName: "UpdateBatch",
			Handler:    _StatDB_UpdateBatch_Handler,
		},
		{
			MethodName: "CreateEntryIfNotExists",
			Handler:    _StatDB_CreateEntryIfNotExists_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "statdb.proto",
}

func init() { proto.RegisterFile("statdb.proto", fileDescriptor_statdb_c60cfd63f3ff5762) }

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