rpc.pb.go

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

/*
	Package wavelet is a generated protocol buffer package.

	It is generated from these files:
		src/rpc.proto

	It has these top-level messages:
		QueryRequest
		QueryResponse
		OutOfSyncRequest
		OutOfSyncResponse
		SyncInfo
		SyncRequest
		SyncResponse
		GossipRequest
		TransactionsSyncRequest
		TransactionsSyncPart
		TransactionsSyncResponse
		TransactionPullRequest
		TransactionPullResponse
*/
package wavelet

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/golang/protobuf/ptypes/empty"

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

import io "io"

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

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

type QueryRequest struct {
	BlockIndex   uint64 `protobuf:"varint,1,opt,name=block_index,json=blockIndex,proto3" json:"block_index,omitempty"`
	CacheBlockId []byte `protobuf:"bytes,2,opt,name=cache_block_id,json=cacheBlockId,proto3" json:"cache_block_id,omitempty"`
}

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

func (m *QueryRequest) GetBlockIndex() uint64 {
	if m != nil {
		return m.BlockIndex
	}
	return 0
}

func (m *QueryRequest) GetCacheBlockId() []byte {
	if m != nil {
		return m.CacheBlockId
	}
	return nil
}

type QueryResponse struct {
	Block      []byte `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
	CacheValid bool   `protobuf:"varint,2,opt,name=cache_valid,json=cacheValid,proto3" json:"cache_valid,omitempty"`
}

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

func (m *QueryResponse) GetBlock() []byte {
	if m != nil {
		return m.Block
	}
	return nil
}

func (m *QueryResponse) GetCacheValid() bool {
	if m != nil {
		return m.CacheValid
	}
	return false
}

type OutOfSyncRequest struct {
	BlockIndex uint64 `protobuf:"varint,1,opt,name=block_index,json=blockIndex,proto3" json:"block_index,omitempty"`
}

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

func (m *OutOfSyncRequest) GetBlockIndex() uint64 {
	if m != nil {
		return m.BlockIndex
	}
	return 0
}

type OutOfSyncResponse struct {
	OutOfSync bool `protobuf:"varint,1,opt,name=out_of_sync,json=outOfSync,proto3" json:"out_of_sync,omitempty"`
}

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

func (m *OutOfSyncResponse) GetOutOfSync() bool {
	if m != nil {
		return m.OutOfSync
	}
	return false
}

type SyncInfo struct {
	Block     []byte   `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
	Checksums [][]byte `protobuf:"bytes,2,rep,name=checksums" json:"checksums,omitempty"`
}

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

func (m *SyncInfo) GetBlock() []byte {
	if m != nil {
		return m.Block
	}
	return nil
}

func (m *SyncInfo) GetChecksums() [][]byte {
	if m != nil {
		return m.Checksums
	}
	return nil
}

type SyncRequest struct {
	// Types that are valid to be assigned to Data:
	//	*SyncRequest_BlockId
	//	*SyncRequest_Checksum
	Data isSyncRequest_Data `protobuf_oneof:"Data"`
}

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

type isSyncRequest_Data interface {
	isSyncRequest_Data()
	MarshalTo([]byte) (int, error)
	Size() int
}

type SyncRequest_BlockId struct {
	BlockId uint64 `protobuf:"varint,1,opt,name=block_id,json=blockId,proto3,oneof"`
}
type SyncRequest_Checksum struct {
	Checksum []byte `protobuf:"bytes,2,opt,name=checksum,proto3,oneof"`
}

func (*SyncRequest_BlockId) isSyncRequest_Data()  {}
func (*SyncRequest_Checksum) isSyncRequest_Data() {}

func (m *SyncRequest) GetData() isSyncRequest_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *SyncRequest) GetBlockId() uint64 {
	if x, ok := m.GetData().(*SyncRequest_BlockId); ok {
		return x.BlockId
	}
	return 0
}

func (m *SyncRequest) GetChecksum() []byte {
	if x, ok := m.GetData().(*SyncRequest_Checksum); ok {
		return x.Checksum
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*SyncRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _SyncRequest_OneofMarshaler, _SyncRequest_OneofUnmarshaler, _SyncRequest_OneofSizer, []interface{}{
		(*SyncRequest_BlockId)(nil),
		(*SyncRequest_Checksum)(nil),
	}
}

func _SyncRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*SyncRequest)
	// Data
	switch x := m.Data.(type) {
	case *SyncRequest_BlockId:
		_ = b.EncodeVarint(1<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.BlockId))
	case *SyncRequest_Checksum:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		_ = b.EncodeRawBytes(x.Checksum)
	case nil:
	default:
		return fmt.Errorf("SyncRequest.Data has unexpected type %T", x)
	}
	return nil
}

func _SyncRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*SyncRequest)
	switch tag {
	case 1: // Data.block_id
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Data = &SyncRequest_BlockId{x}
		return true, err
	case 2: // Data.checksum
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		m.Data = &SyncRequest_Checksum{x}
		return true, err
	default:
		return false, nil
	}
}

func _SyncRequest_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*SyncRequest)
	// Data
	switch x := m.Data.(type) {
	case *SyncRequest_BlockId:
		n += proto.SizeVarint(1<<3 | proto.WireVarint)
		n += proto.SizeVarint(uint64(x.BlockId))
	case *SyncRequest_Checksum:
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(len(x.Checksum)))
		n += len(x.Checksum)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type SyncResponse struct {
	// Types that are valid to be assigned to Data:
	//	*SyncResponse_Header
	//	*SyncResponse_Chunk
	Data isSyncResponse_Data `protobuf_oneof:"Data"`
}

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

type isSyncResponse_Data interface {
	isSyncResponse_Data()
	MarshalTo([]byte) (int, error)
	Size() int
}

type SyncResponse_Header struct {
	Header *SyncInfo `protobuf:"bytes,1,opt,name=header,oneof"`
}
type SyncResponse_Chunk struct {
	Chunk []byte `protobuf:"bytes,2,opt,name=chunk,proto3,oneof"`
}

func (*SyncResponse_Header) isSyncResponse_Data() {}
func (*SyncResponse_Chunk) isSyncResponse_Data()  {}

func (m *SyncResponse) GetData() isSyncResponse_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *SyncResponse) GetHeader() *SyncInfo {
	if x, ok := m.GetData().(*SyncResponse_Header); ok {
		return x.Header
	}
	return nil
}

func (m *SyncResponse) GetChunk() []byte {
	if x, ok := m.GetData().(*SyncResponse_Chunk); ok {
		return x.Chunk
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*SyncResponse) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _SyncResponse_OneofMarshaler, _SyncResponse_OneofUnmarshaler, _SyncResponse_OneofSizer, []interface{}{
		(*SyncResponse_Header)(nil),
		(*SyncResponse_Chunk)(nil),
	}
}

func _SyncResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*SyncResponse)
	// Data
	switch x := m.Data.(type) {
	case *SyncResponse_Header:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Header); err != nil {
			return err
		}
	case *SyncResponse_Chunk:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		_ = b.EncodeRawBytes(x.Chunk)
	case nil:
	default:
		return fmt.Errorf("SyncResponse.Data has unexpected type %T", x)
	}
	return nil
}

func _SyncResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*SyncResponse)
	switch tag {
	case 1: // Data.header
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SyncInfo)
		err := b.DecodeMessage(msg)
		m.Data = &SyncResponse_Header{msg}
		return true, err
	case 2: // Data.chunk
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		m.Data = &SyncResponse_Chunk{x}
		return true, err
	default:
		return false, nil
	}
}

func _SyncResponse_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*SyncResponse)
	// Data
	switch x := m.Data.(type) {
	case *SyncResponse_Header:
		s := proto.Size(x.Header)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *SyncResponse_Chunk:
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(len(x.Chunk)))
		n += len(x.Chunk)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type GossipRequest struct {
	Transactions [][]byte `protobuf:"bytes,1,rep,name=transactions" json:"transactions,omitempty"`
}

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

func (m *GossipRequest) GetTransactions() [][]byte {
	if m != nil {
		return m.Transactions
	}
	return nil
}

type TransactionsSyncRequest struct {
	// Types that are valid to be assigned to Data:
	//	*TransactionsSyncRequest_Filter
	//	*TransactionsSyncRequest_ChunkSize
	Data isTransactionsSyncRequest_Data `protobuf_oneof:"Data"`
}

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

type isTransactionsSyncRequest_Data interface {
	isTransactionsSyncRequest_Data()
	MarshalTo([]byte) (int, error)
	Size() int
}

type TransactionsSyncRequest_Filter struct {
	Filter []byte `protobuf:"bytes,1,opt,name=filter,proto3,oneof"`
}
type TransactionsSyncRequest_ChunkSize struct {
	ChunkSize uint64 `protobuf:"varint,2,opt,name=chunk_size,json=chunkSize,proto3,oneof"`
}

func (*TransactionsSyncRequest_Filter) isTransactionsSyncRequest_Data()    {}
func (*TransactionsSyncRequest_ChunkSize) isTransactionsSyncRequest_Data() {}

func (m *TransactionsSyncRequest) GetData() isTransactionsSyncRequest_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *TransactionsSyncRequest) GetFilter() []byte {
	if x, ok := m.GetData().(*TransactionsSyncRequest_Filter); ok {
		return x.Filter
	}
	return nil
}

func (m *TransactionsSyncRequest) GetChunkSize() uint64 {
	if x, ok := m.GetData().(*TransactionsSyncRequest_ChunkSize); ok {
		return x.ChunkSize
	}
	return 0
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*TransactionsSyncRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TransactionsSyncRequest_OneofMarshaler, _TransactionsSyncRequest_OneofUnmarshaler, _TransactionsSyncRequest_OneofSizer, []interface{}{
		(*TransactionsSyncRequest_Filter)(nil),
		(*TransactionsSyncRequest_ChunkSize)(nil),
	}
}

func _TransactionsSyncRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*TransactionsSyncRequest)
	// Data
	switch x := m.Data.(type) {
	case *TransactionsSyncRequest_Filter:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		_ = b.EncodeRawBytes(x.Filter)
	case *TransactionsSyncRequest_ChunkSize:
		_ = b.EncodeVarint(2<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.ChunkSize))
	case nil:
	default:
		return fmt.Errorf("TransactionsSyncRequest.Data has unexpected type %T", x)
	}
	return nil
}

func _TransactionsSyncRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*TransactionsSyncRequest)
	switch tag {
	case 1: // Data.filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		m.Data = &TransactionsSyncRequest_Filter{x}
		return true, err
	case 2: // Data.chunk_size
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Data = &TransactionsSyncRequest_ChunkSize{x}
		return true, err
	default:
		return false, nil
	}
}

func _TransactionsSyncRequest_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*TransactionsSyncRequest)
	// Data
	switch x := m.Data.(type) {
	case *TransactionsSyncRequest_Filter:
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(len(x.Filter)))
		n += len(x.Filter)
	case *TransactionsSyncRequest_ChunkSize:
		n += proto.SizeVarint(2<<3 | proto.WireVarint)
		n += proto.SizeVarint(uint64(x.ChunkSize))
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type TransactionsSyncPart struct {
	Transactions [][]byte `protobuf:"bytes,1,rep,name=transactions" json:"transactions,omitempty"`
}

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

func (m *TransactionsSyncPart) GetTransactions() [][]byte {
	if m != nil {
		return m.Transactions
	}
	return nil
}

type TransactionsSyncResponse struct {
	// Types that are valid to be assigned to Data:
	//	*TransactionsSyncResponse_TransactionsNum
	//	*TransactionsSyncResponse_Transactions
	Data isTransactionsSyncResponse_Data `protobuf_oneof:"Data"`
}

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

type isTransactionsSyncResponse_Data interface {
	isTransactionsSyncResponse_Data()
	MarshalTo([]byte) (int, error)
	Size() int
}

type TransactionsSyncResponse_TransactionsNum struct {
	TransactionsNum uint64 `protobuf:"varint,1,opt,name=transactions_num,json=transactionsNum,proto3,oneof"`
}
type TransactionsSyncResponse_Transactions struct {
	Transactions *TransactionsSyncPart `protobuf:"bytes,2,opt,name=transactions,oneof"`
}

func (*TransactionsSyncResponse_TransactionsNum) isTransactionsSyncResponse_Data() {}
func (*TransactionsSyncResponse_Transactions) isTransactionsSyncResponse_Data()    {}

func (m *TransactionsSyncResponse) GetData() isTransactionsSyncResponse_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *TransactionsSyncResponse) GetTransactionsNum() uint64 {
	if x, ok := m.GetData().(*TransactionsSyncResponse_TransactionsNum); ok {
		return x.TransactionsNum
	}
	return 0
}

func (m *TransactionsSyncResponse) GetTransactions() *TransactionsSyncPart {
	if x, ok := m.GetData().(*TransactionsSyncResponse_Transactions); ok {
		return x.Transactions
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*TransactionsSyncResponse) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TransactionsSyncResponse_OneofMarshaler, _TransactionsSyncResponse_OneofUnmarshaler, _TransactionsSyncResponse_OneofSizer, []interface{}{
		(*TransactionsSyncResponse_TransactionsNum)(nil),
		(*TransactionsSyncResponse_Transactions)(nil),
	}
}

func _TransactionsSyncResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*TransactionsSyncResponse)
	// Data
	switch x := m.Data.(type) {
	case *TransactionsSyncResponse_TransactionsNum:
		_ = b.EncodeVarint(1<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.TransactionsNum))
	case *TransactionsSyncResponse_Transactions:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Transactions); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("TransactionsSyncResponse.Data has unexpected type %T", x)
	}
	return nil
}

func _TransactionsSyncResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*TransactionsSyncResponse)
	switch tag {
	case 1: // Data.transactions_num
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Data = &TransactionsSyncResponse_TransactionsNum{x}
		return true, err
	case 2: // Data.transactions
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TransactionsSyncPart)
		err := b.DecodeMessage(msg)
		m.Data = &TransactionsSyncResponse_Transactions{msg}
		return true, err
	default:
		return false, nil
	}
}

func _TransactionsSyncResponse_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*TransactionsSyncResponse)
	// Data
	switch x := m.Data.(type) {
	case *TransactionsSyncResponse_TransactionsNum:
		n += proto.SizeVarint(1<<3 | proto.WireVarint)
		n += proto.SizeVarint(uint64(x.TransactionsNum))
	case *TransactionsSyncResponse_Transactions:
		s := proto.Size(x.Transactions)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type TransactionPullRequest struct {
	TransactionIds [][]byte `protobuf:"bytes,1,rep,name=transaction_ids,json=transactionIds" json:"transaction_ids,omitempty"`
}

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

func (m *TransactionPullRequest) GetTransactionIds() [][]byte {
	if m != nil {
		return m.TransactionIds
	}
	return nil
}

type TransactionPullResponse struct {
	Transactions [][]byte `protobuf:"bytes,1,rep,name=transactions" json:"transactions,omitempty"`
}

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

func (m *TransactionPullResponse) GetTransactions() [][]byte {
	if m != nil {
		return m.Transactions
	}
	return nil
}

func init() {
	proto.RegisterType((*QueryRequest)(nil), "wavelet.QueryRequest")
	proto.RegisterType((*QueryResponse)(nil), "wavelet.QueryResponse")
	proto.RegisterType((*OutOfSyncRequest)(nil), "wavelet.OutOfSyncRequest")
	proto.RegisterType((*OutOfSyncResponse)(nil), "wavelet.OutOfSyncResponse")
	proto.RegisterType((*SyncInfo)(nil), "wavelet.SyncInfo")
	proto.RegisterType((*SyncRequest)(nil), "wavelet.SyncRequest")
	proto.RegisterType((*SyncResponse)(nil), "wavelet.SyncResponse")
	proto.RegisterType((*GossipRequest)(nil), "wavelet.GossipRequest")
	proto.RegisterType((*TransactionsSyncRequest)(nil), "wavelet.TransactionsSyncRequest")
	proto.RegisterType((*TransactionsSyncPart)(nil), "wavelet.TransactionsSyncPart")
	proto.RegisterType((*TransactionsSyncResponse)(nil), "wavelet.TransactionsSyncResponse")
	proto.RegisterType((*TransactionPullRequest)(nil), "wavelet.TransactionPullRequest")
	proto.RegisterType((*TransactionPullResponse)(nil), "wavelet.TransactionPullResponse")
}

// 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 Wavelet service

type WaveletClient interface {
	Gossip(ctx context.Context, in *GossipRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
	Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResponse, error)
	CheckOutOfSync(ctx context.Context, in *OutOfSyncRequest, opts ...grpc.CallOption) (*OutOfSyncResponse, error)
	Sync(ctx context.Context, opts ...grpc.CallOption) (Wavelet_SyncClient, error)
	PullTransactions(ctx context.Context, in *TransactionPullRequest, opts ...grpc.CallOption) (*TransactionPullResponse, error)
	SyncTransactions(ctx context.Context, opts ...grpc.CallOption) (Wavelet_SyncTransactionsClient, error)
}

type waveletClient struct {
	cc *grpc.ClientConn
}

func NewWaveletClient(cc *grpc.ClientConn) WaveletClient {
	return &waveletClient{cc}
}

func (c *waveletClient) Gossip(ctx context.Context, in *GossipRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
	out := new(google_protobuf.Empty)
	err := grpc.Invoke(ctx, "/wavelet.Wavelet/Gossip", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *waveletClient) Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResponse, error) {
	out := new(QueryResponse)
	err := grpc.Invoke(ctx, "/wavelet.Wavelet/Query", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *waveletClient) CheckOutOfSync(ctx context.Context, in *OutOfSyncRequest, opts ...grpc.CallOption) (*OutOfSyncResponse, error) {
	out := new(OutOfSyncResponse)
	err := grpc.Invoke(ctx, "/wavelet.Wavelet/CheckOutOfSync", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *waveletClient) Sync(ctx context.Context, opts ...grpc.CallOption) (Wavelet_SyncClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Wavelet_serviceDesc.Streams[0], c.cc, "/wavelet.Wavelet/Sync", opts...)
	if err != nil {
		return nil, err
	}
	x := &waveletSyncClient{stream}
	return x, nil
}

type Wavelet_SyncClient interface {
	Send(*SyncRequest) error
	Recv() (*SyncResponse, error)
	grpc.ClientStream
}

type waveletSyncClient struct {
	grpc.ClientStream
}

func (x *waveletSyncClient) Send(m *SyncRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *waveletSyncClient) Recv() (*SyncResponse, error) {
	m := new(SyncResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *waveletClient) PullTransactions(ctx context.Context, in *TransactionPullRequest, opts ...grpc.CallOption) (*TransactionPullResponse, error) {
	out := new(TransactionPullResponse)
	err := grpc.Invoke(ctx, "/wavelet.Wavelet/PullTransactions", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *waveletClient) SyncTransactions(ctx context.Context, opts ...grpc.CallOption) (Wavelet_SyncTransactionsClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Wavelet_serviceDesc.Streams[1], c.cc, "/wavelet.Wavelet/SyncTransactions", opts...)
	if err != nil {
		return nil, err
	}
	x := &waveletSyncTransactionsClient{stream}
	return x, nil
}

type Wavelet_SyncTransactionsClient interface {
	Send(*TransactionsSyncRequest) error
	Recv() (*TransactionsSyncResponse, error)
	grpc.ClientStream
}

type waveletSyncTransactionsClient struct {
	grpc.ClientStream
}

func (x *waveletSyncTransactionsClient) Send(m *TransactionsSyncRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *waveletSyncTransactionsClient) Recv() (*TransactionsSyncResponse, error) {
	m := new(TransactionsSyncResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Server API for Wavelet service

type WaveletServer interface {
	Gossip(context.Context, *GossipRequest) (*google_protobuf.Empty, error)
	Query(context.Context, *QueryRequest) (*QueryResponse, error)
	CheckOutOfSync(context.Context, *OutOfSyncRequest) (*OutOfSyncResponse, error)
	Sync(Wavelet_SyncServer) error
	PullTransactions(context.Context, *TransactionPullRequest) (*TransactionPullResponse, error)
	SyncTransactions(Wavelet_SyncTransactionsServer) error
}

func RegisterWaveletServer(s *grpc.Server, srv WaveletServer) {
	s.RegisterService(&_Wavelet_serviceDesc, srv)
}

func _Wavelet_Gossip_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GossipRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WaveletServer).Gossip(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/wavelet.Wavelet/Gossip",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WaveletServer).Gossip(ctx, req.(*GossipRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wavelet_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WaveletServer).Query(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/wavelet.Wavelet/Query",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WaveletServer).Query(ctx, req.(*QueryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wavelet_CheckOutOfSync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OutOfSyncRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WaveletServer).CheckOutOfSync(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/wavelet.Wavelet/CheckOutOfSync",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WaveletServer).CheckOutOfSync(ctx, req.(*OutOfSyncRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wavelet_Sync_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(WaveletServer).Sync(&waveletSyncServer{stream})
}

type Wavelet_SyncServer interface {
	Send(*SyncResponse) error
	Recv() (*SyncRequest, error)
	grpc.ServerStream
}

type waveletSyncServer struct {
	grpc.ServerStream
}

func (x *waveletSyncServer) Send(m *SyncResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *waveletSyncServer) Recv() (*SyncRequest, error) {
	m := new(SyncRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Wavelet_PullTransactions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TransactionPullRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WaveletServer).PullTransactions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/wavelet.Wavelet/PullTransactions",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WaveletServer).PullTransactions(ctx, req.(*TransactionPullRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wavelet_SyncTransactions_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(WaveletServer).SyncTransactions(&waveletSyncTransactionsServer{stream})
}

type Wavelet_SyncTransactionsServer interface {
	Send(*TransactionsSyncResponse) error
	Recv() (*TransactionsSyncRequest, error)
	grpc.ServerStream
}

type waveletSyncTransactionsServer struct {
	grpc.ServerStream
}

func (x *waveletSyncTransactionsServer) Send(m *TransactionsSyncResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *waveletSyncTransactionsServer) Recv() (*TransactionsSyncRequest, error) {
	m := new(TransactionsSyncRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _Wavelet_serviceDesc = grpc.ServiceDesc{
	ServiceName: "wavelet.Wavelet",
	HandlerType: (*WaveletServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Gossip",
			Handler:    _Wavelet_Gossip_Handler,
		},
		{
			MethodName: "Query",
			Handler:    _Wavelet_Query_Handler,
		},
		{
			MethodName: "CheckOutOfSync",
			Handler:    _Wavelet_CheckOutOfSync_Handler,
		},
		{
			MethodName: "PullTransactions",
			Handler:    _Wavelet_PullTransactions_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Sync",
			Handler:       _Wavelet_Sync_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "SyncTransactions",
			Handler:       _Wavelet_SyncTransactions_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "src/rpc.proto",
}

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

func (m *QueryRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.BlockIndex != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRpc(dAtA, i, uint64(m.BlockIndex))
	}
	if len(m.CacheBlockId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRpc(dAtA, i, uint64(len(m.CacheBlockId)))
		i += copy(dAtA[i:], m.CacheBlockId)
	}
	return i, nil
}

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

func (m *QueryResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Block) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRpc(dAtA, i, uint64(len(m.Block)))
		i += copy(dAtA[i:], m.Block)
	}
	if m.CacheValid {
		dAtA[i] = 0x10
		i++
		if m.CacheValid {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

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

func (m *OutOfSyncRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.BlockIndex != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRpc(dAtA, i, uint64(m.BlockIndex))
	}
	return i, nil
}

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

func (m *OutOfSyncResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OutOfSync {
		dAtA[i] = 0x8
		i++
		if m.OutOfSync {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

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

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

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

func (m *SyncRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		nn1, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn1
	}
	return i, nil
}

func (m *SyncRequest_BlockId) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x8
	i++
	i = encodeVarintRpc(dAtA, i, uint64(m.BlockId))
	return i, nil
}
func (m *SyncRequest_Checksum) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Checksum != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRpc(dAtA, i, uint64(len(m.Checksum)))
		i += copy(dAtA[i:], m.Checksum)
	}
	return i, nil
}
func (m *SyncResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SyncResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		nn2, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn2
	}
	return i, nil
}

func (m *SyncResponse_Header) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
		n3, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}
func (m *SyncResponse_Chunk) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Chunk != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRpc(dAtA, i, uint64(len(m.Chunk)))
		i += copy(dAtA[i:], m.Chunk)
	}
	return i, nil
}
func (m *GossipRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

func (m *TransactionsSyncRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		nn4, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn4
	}
	return i, nil
}

func (m *TransactionsSyncRequest_Filter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Filter != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRpc(dAtA, i, uint64(len(m.Filter)))
		i += copy(dAtA[i:], m.Filter)
	}
	return i, nil
}
func (m *TransactionsSyncRequest_ChunkSize) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x10
	i++
	i = encodeVarintRpc(dAtA, i, uint64(m.ChunkSize))
	return i, nil
}
func (m *TransactionsSyncPart) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

func (m *TransactionsSyncResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		nn5, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn5
	}
	return i, nil
}

func (m *TransactionsSyncResponse_TransactionsNum) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x8
	i++
	i = encodeVarintRpc(dAtA, i, uint64(m.TransactionsNum))
	return i, nil
}
func (m *TransactionsSyncResponse_Transactions) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Transactions != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRpc(dAtA, i, uint64(m.Transactions.Size()))
		n6, err := m.Transactions.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	return i, nil
}
func (m *TransactionPullRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

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

func encodeFixed64Rpc(dAtA []byte, offset int, v uint64) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	dAtA[offset+4] = uint8(v >> 32)
	dAtA[offset+5] = uint8(v >> 40)
	dAtA[offset+6] = uint8(v >> 48)
	dAtA[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Rpc(dAtA []byte, offset int, v uint32) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintRpc(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *QueryRequest) Size() (n int) {
	var l int
	_ = l
	if m.BlockIndex != 0 {
		n += 1 + sovRpc(uint64(m.BlockIndex))
	}
	l = len(m.CacheBlockId)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	return n
}

func (m *QueryResponse) Size() (n int) {
	var l int
	_ = l
	l = len(m.Block)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.CacheValid {
		n += 2
	}
	return n
}

func (m *OutOfSyncRequest) Size() (n int) {
	var l int
	_ = l
	if m.BlockIndex != 0 {
		n += 1 + sovRpc(uint64(m.BlockIndex))
	}
	return n
}

func (m *OutOfSyncResponse) Size() (n int) {
	var l int
	_ = l
	if m.OutOfSync {
		n += 2
	}
	return n
}

func (m *SyncInfo) Size() (n int) {
	var l int
	_ = l
	l = len(m.Block)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if len(m.Checksums) > 0 {
		for _, b := range m.Checksums {
			l = len(b)
			n += 1 + l + sovRpc(uint64(l))
		}
	}
	return n
}

func (m *SyncRequest) Size() (n int) {
	var l int
	_ = l
	if m.Data != nil {
		n += m.Data.Size()
	}
	return n
}

func (m *SyncRequest_BlockId) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovRpc(uint64(m.BlockId))
	return n
}
func (m *SyncRequest_Checksum) Size() (n int) {
	var l int
	_ = l
	if m.Checksum != nil {
		l = len(m.Checksum)
		n += 1 + l + sovRpc(uint64(l))
	}
	return n
}
func (m *SyncResponse) Size() (n int) {
	var l int
	_ = l
	if m.Data != nil {
		n += m.Data.Size()
	}
	return n
}

func (m *SyncResponse_Header) Size() (n int) {
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	return n
}
func (m *SyncResponse_Chunk) Size() (n int) {
	var l int
	_ = l
	if m.Chunk != nil {
		l = len(m.Chunk)
		n += 1 + l + sovRpc(uint64(l))
	}
	return n
}
func (m *GossipRequest) Size() (n int) {
	var l int
	_ = l
	if len(m.Transactions) > 0 {
		for _, b := range m.Transactions {
			l = len(b)
			n += 1 + l + sovRpc(uint64(l))
		}
	}
	return n
}

func (m *TransactionsSyncRequest) Size() (n int) {
	var l int
	_ = l
	if m.Data != nil {
		n += m.Data.Size()
	}
	return n
}

func (m *TransactionsSyncRequest_Filter) Size() (n int) {
	var l int
	_ = l
	if m.Filter != nil {
		l = len(m.Filter)
		n += 1 + l + sovRpc(uint64(l))
	}
	return n
}
func (m *TransactionsSyncRequest_ChunkSize) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovRpc(uint64(m.ChunkSize))
	return n
}
func (m *TransactionsSyncPart) Size() (n int) {
	var l int
	_ = l
	if len(m.Transactions) > 0 {
		for _, b := range m.Transactions {
			l = len(b)
			n += 1 + l + sovRpc(uint64(l))
		}
	}
	return n
}

func (m *TransactionsSyncResponse) Size() (n int) {
	var l int
	_ = l
	if m.Data != nil {
		n += m.Data.Size()
	}
	return n
}

func (m *TransactionsSyncResponse_TransactionsNum) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovRpc(uint64(m.TransactionsNum))
	return n
}
func (m *TransactionsSyncResponse_Transactions) Size() (n int) {
	var l int
	_ = l
	if m.Transactions != nil {
		l = m.Transactions.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	return n
}
func (m *TransactionPullRequest) Size() (n int) {
	var l int
	_ = l
	if len(m.TransactionIds) > 0 {
		for _, b := range m.TransactionIds {
			l = len(b)
			n += 1 + l + sovRpc(uint64(l))
		}
	}
	return n
}

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

func sovRpc(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozRpc(x uint64) (n int) {
	return sovRpc(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryRequest) 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 ErrIntOverflowRpc
			}
			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: QueryRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIndex", wireType)
			}
			m.BlockIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpc
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockIndex |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CacheBlockId", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpc
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRpc
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CacheBlockId = append(m.CacheBlockId[:0], dAtA[iNdEx:postIndex]...)
			if m.CacheBlockId == nil {
				m.CacheBlockId = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRpc(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRpc
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func init() { proto.RegisterFile("src/rpc.proto", fileDescriptorRpc) }

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