go-cyber/x/rank/types/query.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: cyber/rank/v1beta1/query.proto

package types

import (
	context "context"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = proto.Marshal
	_ = fmt.Errorf
	_ = 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type QueryParamsRequest struct{}

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

func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParamsRequest.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 *QueryParamsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParamsRequest.Merge(m, src)
}

func (m *QueryParamsRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryParamsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

type QueryParamsResponse struct {
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

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

func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParamsResponse.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 *QueryParamsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParamsResponse.Merge(m, src)
}

func (m *QueryParamsResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryParamsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

func (m *QueryParamsResponse) GetParams() Params {
	if m != nil {
		return m.Params
	}
	return Params{}
}

type QueryRankRequest struct {
	Particle string `protobuf:"bytes,1,opt,name=particle,proto3" json:"particle,omitempty"`
}

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

func (m *QueryRankRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryRankRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryRankRequest.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 *QueryRankRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryRankRequest.Merge(m, src)
}

func (m *QueryRankRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryRankRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryRankRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRankRequest proto.InternalMessageInfo

func (m *QueryRankRequest) GetParticle() string {
	if m != nil {
		return m.Particle
	}
	return ""
}

type QueryRankResponse struct {
	Rank uint64 `protobuf:"varint,1,opt,name=rank,proto3" json:"rank,omitempty"`
}

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

func (m *QueryRankResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryRankResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryRankResponse.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 *QueryRankResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryRankResponse.Merge(m, src)
}

func (m *QueryRankResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryRankResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryRankResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRankResponse proto.InternalMessageInfo

func (m *QueryRankResponse) GetRank() uint64 {
	if m != nil {
		return m.Rank
	}
	return 0
}

type QuerySearchRequest struct {
	Particle   string       `protobuf:"bytes,1,opt,name=particle,proto3" json:"particle,omitempty"`
	Pagination *PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

func (m *QuerySearchRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QuerySearchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QuerySearchRequest.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 *QuerySearchRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QuerySearchRequest.Merge(m, src)
}

func (m *QuerySearchRequest) XXX_Size() int {
	return m.Size()
}

func (m *QuerySearchRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QuerySearchRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QuerySearchRequest proto.InternalMessageInfo

func (m *QuerySearchRequest) GetParticle() string {
	if m != nil {
		return m.Particle
	}
	return ""
}

func (m *QuerySearchRequest) GetPagination() *PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QuerySearchResponse struct {
	Result     []RankedParticle `protobuf:"bytes,1,rep,name=result,proto3" json:"result"`
	Pagination *PageResponse    `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

func (m *QuerySearchResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QuerySearchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QuerySearchResponse.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 *QuerySearchResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QuerySearchResponse.Merge(m, src)
}

func (m *QuerySearchResponse) XXX_Size() int {
	return m.Size()
}

func (m *QuerySearchResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QuerySearchResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QuerySearchResponse proto.InternalMessageInfo

func (m *QuerySearchResponse) GetResult() []RankedParticle {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *QuerySearchResponse) GetPagination() *PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryTopRequest struct {
	Pagination *PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

func (m *QueryTopRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryTopRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryTopRequest.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 *QueryTopRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryTopRequest.Merge(m, src)
}

func (m *QueryTopRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryTopRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryTopRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryTopRequest proto.InternalMessageInfo

func (m *QueryTopRequest) GetPagination() *PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryIsLinkExistRequest struct {
	From    string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	To      string `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"`
	Address string `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
}

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

func (m *QueryIsLinkExistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryIsLinkExistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryIsLinkExistRequest.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 *QueryIsLinkExistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryIsLinkExistRequest.Merge(m, src)
}

func (m *QueryIsLinkExistRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryIsLinkExistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryIsLinkExistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryIsLinkExistRequest proto.InternalMessageInfo

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

func (m *QueryIsLinkExistRequest) GetTo() string {
	if m != nil {
		return m.To
	}
	return ""
}

func (m *QueryIsLinkExistRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type QueryIsAnyLinkExistRequest struct {
	From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	To   string `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"`
}

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

func (m *QueryIsAnyLinkExistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryIsAnyLinkExistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryIsAnyLinkExistRequest.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 *QueryIsAnyLinkExistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryIsAnyLinkExistRequest.Merge(m, src)
}

func (m *QueryIsAnyLinkExistRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryIsAnyLinkExistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryIsAnyLinkExistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryIsAnyLinkExistRequest proto.InternalMessageInfo

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

func (m *QueryIsAnyLinkExistRequest) GetTo() string {
	if m != nil {
		return m.To
	}
	return ""
}

type QueryLinkExistResponse struct {
	Exist bool `protobuf:"varint,1,opt,name=exist,proto3" json:"exist,omitempty"`
}

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

func (m *QueryLinkExistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryLinkExistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryLinkExistResponse.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 *QueryLinkExistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryLinkExistResponse.Merge(m, src)
}

func (m *QueryLinkExistResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryLinkExistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryLinkExistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryLinkExistResponse proto.InternalMessageInfo

func (m *QueryLinkExistResponse) GetExist() bool {
	if m != nil {
		return m.Exist
	}
	return false
}

type QueryNegentropyPartilceRequest struct {
	Particle string `protobuf:"bytes,1,opt,name=particle,proto3" json:"particle,omitempty"`
}

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

func (m *QueryNegentropyPartilceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryNegentropyPartilceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryNegentropyPartilceRequest.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 *QueryNegentropyPartilceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryNegentropyPartilceRequest.Merge(m, src)
}

func (m *QueryNegentropyPartilceRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryNegentropyPartilceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryNegentropyPartilceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNegentropyPartilceRequest proto.InternalMessageInfo

func (m *QueryNegentropyPartilceRequest) GetParticle() string {
	if m != nil {
		return m.Particle
	}
	return ""
}

type QueryNegentropyParticleResponse struct {
	Entropy uint64 `protobuf:"varint,1,opt,name=entropy,proto3" json:"entropy,omitempty"`
}

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

func (m *QueryNegentropyParticleResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryNegentropyParticleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryNegentropyParticleResponse.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 *QueryNegentropyParticleResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryNegentropyParticleResponse.Merge(m, src)
}

func (m *QueryNegentropyParticleResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryNegentropyParticleResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryNegentropyParticleResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNegentropyParticleResponse proto.InternalMessageInfo

func (m *QueryNegentropyParticleResponse) GetEntropy() uint64 {
	if m != nil {
		return m.Entropy
	}
	return 0
}

type QueryNegentropyRequest struct{}

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

func (m *QueryNegentropyRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryNegentropyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryNegentropyRequest.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 *QueryNegentropyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryNegentropyRequest.Merge(m, src)
}

func (m *QueryNegentropyRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryNegentropyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryNegentropyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNegentropyRequest proto.InternalMessageInfo

type QueryNegentropyResponse struct {
	Negentropy uint64 `protobuf:"varint,1,opt,name=negentropy,proto3" json:"negentropy,omitempty"`
}

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

func (m *QueryNegentropyResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryNegentropyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryNegentropyResponse.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 *QueryNegentropyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryNegentropyResponse.Merge(m, src)
}

func (m *QueryNegentropyResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryNegentropyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryNegentropyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNegentropyResponse proto.InternalMessageInfo

func (m *QueryNegentropyResponse) GetNegentropy() uint64 {
	if m != nil {
		return m.Negentropy
	}
	return 0
}

type QueryKarmaRequest struct {
	Neuron string `protobuf:"bytes,1,opt,name=neuron,proto3" json:"neuron,omitempty"`
}

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

func (m *QueryKarmaRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryKarmaRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryKarmaRequest.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 *QueryKarmaRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryKarmaRequest.Merge(m, src)
}

func (m *QueryKarmaRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryKarmaRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryKarmaRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryKarmaRequest proto.InternalMessageInfo

func (m *QueryKarmaRequest) GetNeuron() string {
	if m != nil {
		return m.Neuron
	}
	return ""
}

type QueryKarmaResponse struct {
	Karma uint64 `protobuf:"varint,1,opt,name=karma,proto3" json:"karma,omitempty"`
}

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

func (m *QueryKarmaResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryKarmaResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryKarmaResponse.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 *QueryKarmaResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryKarmaResponse.Merge(m, src)
}

func (m *QueryKarmaResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryKarmaResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryKarmaResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryKarmaResponse proto.InternalMessageInfo

func (m *QueryKarmaResponse) GetKarma() uint64 {
	if m != nil {
		return m.Karma
	}
	return 0
}

func init() {
	proto.RegisterType((*QueryParamsRequest)(nil), "cyber.rank.v1beta1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "cyber.rank.v1beta1.QueryParamsResponse")
	proto.RegisterType((*QueryRankRequest)(nil), "cyber.rank.v1beta1.QueryRankRequest")
	proto.RegisterType((*QueryRankResponse)(nil), "cyber.rank.v1beta1.QueryRankResponse")
	proto.RegisterType((*QuerySearchRequest)(nil), "cyber.rank.v1beta1.QuerySearchRequest")
	proto.RegisterType((*QuerySearchResponse)(nil), "cyber.rank.v1beta1.QuerySearchResponse")
	proto.RegisterType((*QueryTopRequest)(nil), "cyber.rank.v1beta1.QueryTopRequest")
	proto.RegisterType((*QueryIsLinkExistRequest)(nil), "cyber.rank.v1beta1.QueryIsLinkExistRequest")
	proto.RegisterType((*QueryIsAnyLinkExistRequest)(nil), "cyber.rank.v1beta1.QueryIsAnyLinkExistRequest")
	proto.RegisterType((*QueryLinkExistResponse)(nil), "cyber.rank.v1beta1.QueryLinkExistResponse")
	proto.RegisterType((*QueryNegentropyPartilceRequest)(nil), "cyber.rank.v1beta1.QueryNegentropyPartilceRequest")
	proto.RegisterType((*QueryNegentropyParticleResponse)(nil), "cyber.rank.v1beta1.QueryNegentropyParticleResponse")
	proto.RegisterType((*QueryNegentropyRequest)(nil), "cyber.rank.v1beta1.QueryNegentropyRequest")
	proto.RegisterType((*QueryNegentropyResponse)(nil), "cyber.rank.v1beta1.QueryNegentropyResponse")
	proto.RegisterType((*QueryKarmaRequest)(nil), "cyber.rank.v1beta1.QueryKarmaRequest")
	proto.RegisterType((*QueryKarmaResponse)(nil), "cyber.rank.v1beta1.QueryKarmaResponse")
}

func init() { proto.RegisterFile("cyber/rank/v1beta1/query.proto", fileDescriptor_f72c23904714eae6) }

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

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ context.Context
	_ 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

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	Rank(ctx context.Context, in *QueryRankRequest, opts ...grpc.CallOption) (*QueryRankResponse, error)
	Search(ctx context.Context, in *QuerySearchRequest, opts ...grpc.CallOption) (*QuerySearchResponse, error)
	Backlinks(ctx context.Context, in *QuerySearchRequest, opts ...grpc.CallOption) (*QuerySearchResponse, error)
	Top(ctx context.Context, in *QueryTopRequest, opts ...grpc.CallOption) (*QuerySearchResponse, error)
	IsLinkExist(ctx context.Context, in *QueryIsLinkExistRequest, opts ...grpc.CallOption) (*QueryLinkExistResponse, error)
	IsAnyLinkExist(ctx context.Context, in *QueryIsAnyLinkExistRequest, opts ...grpc.CallOption) (*QueryLinkExistResponse, error)
	ParticleNegentropy(ctx context.Context, in *QueryNegentropyPartilceRequest, opts ...grpc.CallOption) (*QueryNegentropyParticleResponse, error)
	Negentropy(ctx context.Context, in *QueryNegentropyRequest, opts ...grpc.CallOption) (*QueryNegentropyResponse, error)
	Karma(ctx context.Context, in *QueryKarmaRequest, opts ...grpc.CallOption) (*QueryKarmaResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

func NewQueryClient(cc grpc1.ClientConn) QueryClient {
	return &queryClient{cc}
}

func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
	out := new(QueryParamsResponse)
	err := c.cc.Invoke(ctx, "/cyber.rank.v1beta1.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Rank(ctx context.Context, in *QueryRankRequest, opts ...grpc.CallOption) (*QueryRankResponse, error) {
	out := new(QueryRankResponse)
	err := c.cc.Invoke(ctx, "/cyber.rank.v1beta1.Query/Rank", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Search(ctx context.Context, in *QuerySearchRequest, opts ...grpc.CallOption) (*QuerySearchResponse, error) {
	out := new(QuerySearchResponse)
	err := c.cc.Invoke(ctx, "/cyber.rank.v1beta1.Query/Search", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Backlinks(ctx context.Context, in *QuerySearchRequest, opts ...grpc.CallOption) (*QuerySearchResponse, error) {
	out := new(QuerySearchResponse)
	err := c.cc.Invoke(ctx, "/cyber.rank.v1beta1.Query/Backlinks", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Top(ctx context.Context, in *QueryTopRequest, opts ...grpc.CallOption) (*QuerySearchResponse, error) {
	out := new(QuerySearchResponse)
	err := c.cc.Invoke(ctx, "/cyber.rank.v1beta1.Query/Top", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) IsLinkExist(ctx context.Context, in *QueryIsLinkExistRequest, opts ...grpc.CallOption) (*QueryLinkExistResponse, error) {
	out := new(QueryLinkExistResponse)
	err := c.cc.Invoke(ctx, "/cyber.rank.v1beta1.Query/IsLinkExist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) IsAnyLinkExist(ctx context.Context, in *QueryIsAnyLinkExistRequest, opts ...grpc.CallOption) (*QueryLinkExistResponse, error) {
	out := new(QueryLinkExistResponse)
	err := c.cc.Invoke(ctx, "/cyber.rank.v1beta1.Query/IsAnyLinkExist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ParticleNegentropy(ctx context.Context, in *QueryNegentropyPartilceRequest, opts ...grpc.CallOption) (*QueryNegentropyParticleResponse, error) {
	out := new(QueryNegentropyParticleResponse)
	err := c.cc.Invoke(ctx, "/cyber.rank.v1beta1.Query/ParticleNegentropy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Negentropy(ctx context.Context, in *QueryNegentropyRequest, opts ...grpc.CallOption) (*QueryNegentropyResponse, error) {
	out := new(QueryNegentropyResponse)
	err := c.cc.Invoke(ctx, "/cyber.rank.v1beta1.Query/Negentropy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Karma(ctx context.Context, in *QueryKarmaRequest, opts ...grpc.CallOption) (*QueryKarmaResponse, error) {
	out := new(QueryKarmaResponse)
	err := c.cc.Invoke(ctx, "/cyber.rank.v1beta1.Query/Karma", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	Rank(context.Context, *QueryRankRequest) (*QueryRankResponse, error)
	Search(context.Context, *QuerySearchRequest) (*QuerySearchResponse, error)
	Backlinks(context.Context, *QuerySearchRequest) (*QuerySearchResponse, error)
	Top(context.Context, *QueryTopRequest) (*QuerySearchResponse, error)
	IsLinkExist(context.Context, *QueryIsLinkExistRequest) (*QueryLinkExistResponse, error)
	IsAnyLinkExist(context.Context, *QueryIsAnyLinkExistRequest) (*QueryLinkExistResponse, error)
	ParticleNegentropy(context.Context, *QueryNegentropyPartilceRequest) (*QueryNegentropyParticleResponse, error)
	Negentropy(context.Context, *QueryNegentropyRequest) (*QueryNegentropyResponse, error)
	Karma(context.Context, *QueryKarmaRequest) (*QueryKarmaResponse, error)
}

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

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}

func (*UnimplementedQueryServer) Rank(ctx context.Context, req *QueryRankRequest) (*QueryRankResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Rank not implemented")
}

func (*UnimplementedQueryServer) Search(ctx context.Context, req *QuerySearchRequest) (*QuerySearchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Search not implemented")
}

func (*UnimplementedQueryServer) Backlinks(ctx context.Context, req *QuerySearchRequest) (*QuerySearchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Backlinks not implemented")
}

func (*UnimplementedQueryServer) Top(ctx context.Context, req *QueryTopRequest) (*QuerySearchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Top not implemented")
}

func (*UnimplementedQueryServer) IsLinkExist(ctx context.Context, req *QueryIsLinkExistRequest) (*QueryLinkExistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IsLinkExist not implemented")
}

func (*UnimplementedQueryServer) IsAnyLinkExist(ctx context.Context, req *QueryIsAnyLinkExistRequest) (*QueryLinkExistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IsAnyLinkExist not implemented")
}

func (*UnimplementedQueryServer) ParticleNegentropy(ctx context.Context, req *QueryNegentropyPartilceRequest) (*QueryNegentropyParticleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ParticleNegentropy not implemented")
}

func (*UnimplementedQueryServer) Negentropy(ctx context.Context, req *QueryNegentropyRequest) (*QueryNegentropyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Negentropy not implemented")
}

func (*UnimplementedQueryServer) Karma(ctx context.Context, req *QueryKarmaRequest) (*QueryKarmaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Karma not implemented")
}

func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
	s.RegisterService(&_Query_serviceDesc, srv)
}

func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.rank.v1beta1.Query/Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Rank_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryRankRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Rank(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.rank.v1beta1.Query/Rank",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Rank(ctx, req.(*QueryRankRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Search_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QuerySearchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Search(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.rank.v1beta1.Query/Search",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Search(ctx, req.(*QuerySearchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Backlinks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QuerySearchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Backlinks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.rank.v1beta1.Query/Backlinks",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Backlinks(ctx, req.(*QuerySearchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Top_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryTopRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Top(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.rank.v1beta1.Query/Top",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Top(ctx, req.(*QueryTopRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_IsLinkExist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryIsLinkExistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).IsLinkExist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.rank.v1beta1.Query/IsLinkExist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).IsLinkExist(ctx, req.(*QueryIsLinkExistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_IsAnyLinkExist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryIsAnyLinkExistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).IsAnyLinkExist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.rank.v1beta1.Query/IsAnyLinkExist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).IsAnyLinkExist(ctx, req.(*QueryIsAnyLinkExistRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ParticleNegentropy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryNegentropyPartilceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ParticleNegentropy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.rank.v1beta1.Query/ParticleNegentropy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ParticleNegentropy(ctx, req.(*QueryNegentropyPartilceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Negentropy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryNegentropyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Negentropy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.rank.v1beta1.Query/Negentropy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Negentropy(ctx, req.(*QueryNegentropyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Karma_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryKarmaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Karma(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.rank.v1beta1.Query/Karma",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Karma(ctx, req.(*QueryKarmaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "cyber.rank.v1beta1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "Rank",
			Handler:    _Query_Rank_Handler,
		},
		{
			MethodName: "Search",
			Handler:    _Query_Search_Handler,
		},
		{
			MethodName: "Backlinks",
			Handler:    _Query_Backlinks_Handler,
		},
		{
			MethodName: "Top",
			Handler:    _Query_Top_Handler,
		},
		{
			MethodName: "IsLinkExist",
			Handler:    _Query_IsLinkExist_Handler,
		},
		{
			MethodName: "IsAnyLinkExist",
			Handler:    _Query_IsAnyLinkExist_Handler,
		},
		{
			MethodName: "ParticleNegentropy",
			Handler:    _Query_ParticleNegentropy_Handler,
		},
		{
			MethodName: "Negentropy",
			Handler:    _Query_Negentropy_Handler,
		},
		{
			MethodName: "Karma",
			Handler:    _Query_Karma_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "cyber/rank/v1beta1/query.proto",
}

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

func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryRankResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Rank != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Rank))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *QuerySearchRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Particle) > 0 {
		i -= len(m.Particle)
		copy(dAtA[i:], m.Particle)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Particle)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QuerySearchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Result) > 0 {
		for iNdEx := len(m.Result) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Result[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryTopRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryIsLinkExistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.To) > 0 {
		i -= len(m.To)
		copy(dAtA[i:], m.To)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.To)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryIsAnyLinkExistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.To) > 0 {
		i -= len(m.To)
		copy(dAtA[i:], m.To)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.To)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryLinkExistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Exist {
		i--
		if m.Exist {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryNegentropyParticleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Entropy != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Entropy))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryNegentropyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *QueryNegentropyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Negentropy != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Negentropy))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryKarmaResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Karma != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Karma))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
	offset -= sovQuery(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}

func (m *QueryParamsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryParamsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

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

func (m *QueryRankResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Rank != 0 {
		n += 1 + sovQuery(uint64(m.Rank))
	}
	return n
}

func (m *QuerySearchRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Particle)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *QueryTopRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryIsLinkExistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.From)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.To)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryIsAnyLinkExistRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.From)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.To)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryLinkExistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Exist {
		n += 2
	}
	return n
}

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

func (m *QueryNegentropyParticleResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Entropy != 0 {
		n += 1 + sovQuery(uint64(m.Entropy))
	}
	return n
}

func (m *QueryNegentropyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryNegentropyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Negentropy != 0 {
		n += 1 + sovQuery(uint64(m.Negentropy))
	}
	return n
}

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

func (m *QueryKarmaResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Karma != 0 {
		n += 1 + sovQuery(uint64(m.Karma))
	}
	return n
}

func sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}

func sozQuery(x uint64) (n int) {
	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}

func (m *QueryParamsRequest) 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 ErrIntOverflowQuery
			}
			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: QueryParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *QueryRankRequest) 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 ErrIntOverflowQuery
			}
			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: QueryRankRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRankRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Particle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Particle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *QueryRankResponse) 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 ErrIntOverflowQuery
			}
			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: QueryRankResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRankResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rank", wireType)
			}
			m.Rank = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Rank |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *QueryIsLinkExistRequest) 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 ErrIntOverflowQuery
			}
			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: QueryIsLinkExistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIsLinkExistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.From = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.To = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *QueryIsAnyLinkExistRequest) 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 ErrIntOverflowQuery
			}
			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: QueryIsAnyLinkExistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIsAnyLinkExistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.From = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.To = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *QueryNegentropyPartilceRequest) 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 ErrIntOverflowQuery
			}
			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: QueryNegentropyPartilceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryNegentropyPartilceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Particle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Particle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *QueryNegentropyParticleResponse) 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 ErrIntOverflowQuery
			}
			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: QueryNegentropyParticleResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryNegentropyParticleResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entropy", wireType)
			}
			m.Entropy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Entropy |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *QueryNegentropyRequest) 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 ErrIntOverflowQuery
			}
			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: QueryNegentropyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryNegentropyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *QueryNegentropyResponse) 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 ErrIntOverflowQuery
			}
			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: QueryNegentropyResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryNegentropyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Negentropy", wireType)
			}
			m.Negentropy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Negentropy |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *QueryKarmaRequest) 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 ErrIntOverflowQuery
			}
			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: QueryKarmaRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryKarmaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Neuron", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Neuron = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *QueryKarmaResponse) 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 ErrIntOverflowQuery
			}
			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: QueryKarmaResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryKarmaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Karma", wireType)
			}
			m.Karma = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Karma |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func skipQuery(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, ErrIntOverflowQuery
			}
			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, ErrIntOverflowQuery
				}
				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, ErrIntOverflowQuery
				}
				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, ErrInvalidLengthQuery
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupQuery
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthQuery
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)