vldm.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: vldm.proto

package vldmpb

/*
Version 1.0
*/

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

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

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

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

type SubscribeParams struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SubscribeParams proto.InternalMessageInfo

type MapHead struct {
	TrillianSignedMapRoot []byte   `protobuf:"bytes,1,opt,name=trillianSignedMapRoot,proto3" json:"trillianSignedMapRoot,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

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

var xxx_messageInfo_MapHead proto.InternalMessageInfo

func (m *MapHead) GetTrillianSignedMapRoot() []byte {
	if m != nil {
		return m.TrillianSignedMapRoot
	}
	return nil
}

type SubmitParams struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SubmitParams proto.InternalMessageInfo

type SubmitResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SubmitResponse proto.InternalMessageInfo

type GetLogHeadParams struct {
	// True if this is the oplog, false if it's the root log
	IsOperation          bool     `protobuf:"varint,1,opt,name=isOperation,proto3" json:"isOperation,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetLogHeadParams proto.InternalMessageInfo

func (m *GetLogHeadParams) GetIsOperation() bool {
	if m != nil {
		return m.IsOperation
	}
	return false
}

type GetLogHeadResponse struct {
	TrillianSignedLogRoot []byte   `protobuf:"bytes,1,opt,name=trillianSignedLogRoot,proto3" json:"trillianSignedLogRoot,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

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

var xxx_messageInfo_GetLogHeadResponse proto.InternalMessageInfo

func (m *GetLogHeadResponse) GetTrillianSignedLogRoot() []byte {
	if m != nil {
		return m.TrillianSignedLogRoot
	}
	return nil
}

type GetConsistencyParams struct {
	// True if this is the oplog, false if it's the root log
	IsOperation          bool     `protobuf:"varint,1,opt,name=isOperation,proto3" json:"isOperation,omitempty"`
	From                 int64    `protobuf:"varint,2,opt,name=from,proto3" json:"from,omitempty"`
	To                   int64    `protobuf:"varint,3,opt,name=to,proto3" json:"to,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetConsistencyParams proto.InternalMessageInfo

func (m *GetConsistencyParams) GetIsOperation() bool {
	if m != nil {
		return m.IsOperation
	}
	return false
}

func (m *GetConsistencyParams) GetFrom() int64 {
	if m != nil {
		return m.From
	}
	return 0
}

func (m *GetConsistencyParams) GetTo() int64 {
	if m != nil {
		return m.To
	}
	return 0
}

type GetConsistencyResponse struct {
	TrillianProof        []byte   `protobuf:"bytes,1,opt,name=trillianProof,proto3" json:"trillianProof,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetConsistencyResponse proto.InternalMessageInfo

func (m *GetConsistencyResponse) GetTrillianProof() []byte {
	if m != nil {
		return m.TrillianProof
	}
	return nil
}

type GetLogItemParams struct {
	// True if this is the oplog, false if it's the root log
	IsOperation          bool     `protobuf:"varint,1,opt,name=isOperation,proto3" json:"isOperation,omitempty"`
	Index                int64    `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	Size                 int64    `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetLogItemParams proto.InternalMessageInfo

func (m *GetLogItemParams) GetIsOperation() bool {
	if m != nil {
		return m.IsOperation
	}
	return false
}

func (m *GetLogItemParams) GetIndex() int64 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *GetLogItemParams) GetSize() int64 {
	if m != nil {
		return m.Size
	}
	return 0
}

type GetLogItemResponse struct {
	TrillianGetEntryAndProofResponse []byte   `protobuf:"bytes,1,opt,name=trillianGetEntryAndProofResponse,proto3" json:"trillianGetEntryAndProofResponse,omitempty"`
	XXX_NoUnkeyedLiteral             struct{} `json:"-"`
	XXX_unrecognized                 []byte   `json:"-"`
	XXX_sizecache                    int32    `json:"-"`
}

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

var xxx_messageInfo_GetLogItemResponse proto.InternalMessageInfo

func (m *GetLogItemResponse) GetTrillianGetEntryAndProofResponse() []byte {
	if m != nil {
		return m.TrillianGetEntryAndProofResponse
	}
	return nil
}

// Used internally
type MapperMetadata struct {
	HighestFullyCompletedSeq int64    `protobuf:"varint,1,opt,name=highest_fully_completed_seq,json=highestFullyCompletedSeq,proto3" json:"highest_fully_completed_seq,omitempty"`
	XXX_NoUnkeyedLiteral     struct{} `json:"-"`
	XXX_unrecognized         []byte   `json:"-"`
	XXX_sizecache            int32    `json:"-"`
}

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

var xxx_messageInfo_MapperMetadata proto.InternalMessageInfo

func (m *MapperMetadata) GetHighestFullyCompletedSeq() int64 {
	if m != nil {
		return m.HighestFullyCompletedSeq
	}
	return 0
}

type SubmitLogRootParams struct {
	SignedLogRoot        []byte   `protobuf:"bytes,1,opt,name=SignedLogRoot,proto3" json:"SignedLogRoot,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SubmitLogRootParams proto.InternalMessageInfo

func (m *SubmitLogRootParams) GetSignedLogRoot() []byte {
	if m != nil {
		return m.SignedLogRoot
	}
	return nil
}

type SubmitLogRootResponse struct {
	Trustworthy          bool     `protobuf:"varint,1,opt,name=trustworthy,proto3" json:"trustworthy,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SubmitLogRootResponse proto.InternalMessageInfo

func (m *SubmitLogRootResponse) GetTrustworthy() bool {
	if m != nil {
		return m.Trustworthy
	}
	return false
}

type GetPeersParams struct {
	Publickey            string   `protobuf:"bytes,1,opt,name=publickey,proto3" json:"publickey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetPeersParams proto.InternalMessageInfo

func (m *GetPeersParams) GetPublickey() string {
	if m != nil {
		return m.Publickey
	}
	return ""
}

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

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

var xxx_messageInfo_GetPeersResponse proto.InternalMessageInfo

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

func init() {
	proto.RegisterType((*SubscribeParams)(nil), "vldmpb.SubscribeParams")
	proto.RegisterType((*MapHead)(nil), "vldmpb.MapHead")
	proto.RegisterType((*SubmitParams)(nil), "vldmpb.SubmitParams")
	proto.RegisterType((*SubmitResponse)(nil), "vldmpb.SubmitResponse")
	proto.RegisterType((*GetLogHeadParams)(nil), "vldmpb.GetLogHeadParams")
	proto.RegisterType((*GetLogHeadResponse)(nil), "vldmpb.GetLogHeadResponse")
	proto.RegisterType((*GetConsistencyParams)(nil), "vldmpb.GetConsistencyParams")
	proto.RegisterType((*GetConsistencyResponse)(nil), "vldmpb.GetConsistencyResponse")
	proto.RegisterType((*GetLogItemParams)(nil), "vldmpb.GetLogItemParams")
	proto.RegisterType((*GetLogItemResponse)(nil), "vldmpb.GetLogItemResponse")
	proto.RegisterType((*MapperMetadata)(nil), "vldmpb.MapperMetadata")
	proto.RegisterType((*SubmitLogRootParams)(nil), "vldmpb.SubmitLogRootParams")
	proto.RegisterType((*SubmitLogRootResponse)(nil), "vldmpb.SubmitLogRootResponse")
	proto.RegisterType((*GetPeersParams)(nil), "vldmpb.GetPeersParams")
	proto.RegisterType((*GetPeersResponse)(nil), "vldmpb.GetPeersResponse")
}

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

// VLDMClient is the client API for VLDM service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VLDMClient interface {
	// For certifiers
	SubmitSignedMapHead(ctx context.Context, in *SubmitParams, opts ...grpc.CallOption) (*SubmitResponse, error)
	// For certifiers and auditors
	SubscribeMapHeads(ctx context.Context, in *SubscribeParams, opts ...grpc.CallOption) (VLDM_SubscribeMapHeadsClient, error)
	GetLogHead(ctx context.Context, in *GetLogHeadParams, opts ...grpc.CallOption) (*GetLogHeadResponse, error)
	GetLogConsistency(ctx context.Context, in *GetConsistencyParams, opts ...grpc.CallOption) (*GetConsistencyResponse, error)
	GetLogItem(ctx context.Context, in *GetLogItemParams, opts ...grpc.CallOption) (*GetLogItemResponse, error)
}

type vLDMClient struct {
	cc *grpc.ClientConn
}

func NewVLDMClient(cc *grpc.ClientConn) VLDMClient {
	return &vLDMClient{cc}
}

func (c *vLDMClient) SubmitSignedMapHead(ctx context.Context, in *SubmitParams, opts ...grpc.CallOption) (*SubmitResponse, error) {
	out := new(SubmitResponse)
	err := c.cc.Invoke(ctx, "/vldmpb.VLDM/SubmitSignedMapHead", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vLDMClient) SubscribeMapHeads(ctx context.Context, in *SubscribeParams, opts ...grpc.CallOption) (VLDM_SubscribeMapHeadsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_VLDM_serviceDesc.Streams[0], "/vldmpb.VLDM/SubscribeMapHeads", opts...)
	if err != nil {
		return nil, err
	}
	x := &vLDMSubscribeMapHeadsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type VLDM_SubscribeMapHeadsClient interface {
	Recv() (*MapHead, error)
	grpc.ClientStream
}

type vLDMSubscribeMapHeadsClient struct {
	grpc.ClientStream
}

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

func (c *vLDMClient) GetLogHead(ctx context.Context, in *GetLogHeadParams, opts ...grpc.CallOption) (*GetLogHeadResponse, error) {
	out := new(GetLogHeadResponse)
	err := c.cc.Invoke(ctx, "/vldmpb.VLDM/GetLogHead", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vLDMClient) GetLogConsistency(ctx context.Context, in *GetConsistencyParams, opts ...grpc.CallOption) (*GetConsistencyResponse, error) {
	out := new(GetConsistencyResponse)
	err := c.cc.Invoke(ctx, "/vldmpb.VLDM/GetLogConsistency", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vLDMClient) GetLogItem(ctx context.Context, in *GetLogItemParams, opts ...grpc.CallOption) (*GetLogItemResponse, error) {
	out := new(GetLogItemResponse)
	err := c.cc.Invoke(ctx, "/vldmpb.VLDM/GetLogItem", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VLDMServer is the server API for VLDM service.
type VLDMServer interface {
	// For certifiers
	SubmitSignedMapHead(context.Context, *SubmitParams) (*SubmitResponse, error)
	// For certifiers and auditors
	SubscribeMapHeads(*SubscribeParams, VLDM_SubscribeMapHeadsServer) error
	GetLogHead(context.Context, *GetLogHeadParams) (*GetLogHeadResponse, error)
	GetLogConsistency(context.Context, *GetConsistencyParams) (*GetConsistencyResponse, error)
	GetLogItem(context.Context, *GetLogItemParams) (*GetLogItemResponse, error)
}

func RegisterVLDMServer(s *grpc.Server, srv VLDMServer) {
	s.RegisterService(&_VLDM_serviceDesc, srv)
}

func _VLDM_SubmitSignedMapHead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubmitParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VLDMServer).SubmitSignedMapHead(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/vldmpb.VLDM/SubmitSignedMapHead",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VLDMServer).SubmitSignedMapHead(ctx, req.(*SubmitParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _VLDM_SubscribeMapHeads_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeParams)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(VLDMServer).SubscribeMapHeads(m, &vLDMSubscribeMapHeadsServer{stream})
}

type VLDM_SubscribeMapHeadsServer interface {
	Send(*MapHead) error
	grpc.ServerStream
}

type vLDMSubscribeMapHeadsServer struct {
	grpc.ServerStream
}

func (x *vLDMSubscribeMapHeadsServer) Send(m *MapHead) error {
	return x.ServerStream.SendMsg(m)
}

func _VLDM_GetLogHead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLogHeadParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VLDMServer).GetLogHead(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/vldmpb.VLDM/GetLogHead",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VLDMServer).GetLogHead(ctx, req.(*GetLogHeadParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _VLDM_GetLogConsistency_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetConsistencyParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VLDMServer).GetLogConsistency(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/vldmpb.VLDM/GetLogConsistency",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VLDMServer).GetLogConsistency(ctx, req.(*GetConsistencyParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _VLDM_GetLogItem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLogItemParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VLDMServer).GetLogItem(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/vldmpb.VLDM/GetLogItem",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VLDMServer).GetLogItem(ctx, req.(*GetLogItemParams))
	}
	return interceptor(ctx, in, info, handler)
}

var _VLDM_serviceDesc = grpc.ServiceDesc{
	ServiceName: "vldmpb.VLDM",
	HandlerType: (*VLDMServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SubmitSignedMapHead",
			Handler:    _VLDM_SubmitSignedMapHead_Handler,
		},
		{
			MethodName: "GetLogHead",
			Handler:    _VLDM_GetLogHead_Handler,
		},
		{
			MethodName: "GetLogConsistency",
			Handler:    _VLDM_GetLogConsistency_Handler,
		},
		{
			MethodName: "GetLogItem",
			Handler:    _VLDM_GetLogItem_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SubscribeMapHeads",
			Handler:       _VLDM_SubscribeMapHeads_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "vldm.proto",
}

// AuditorClient is the client API for Auditor service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AuditorClient interface {
	SubmitLogRoot(ctx context.Context, in *SubmitLogRootParams, opts ...grpc.CallOption) (*SubmitLogRootResponse, error)
	GetPeers(ctx context.Context, in *GetPeersParams, opts ...grpc.CallOption) (*GetPeersResponse, error)
}

type auditorClient struct {
	cc *grpc.ClientConn
}

func NewAuditorClient(cc *grpc.ClientConn) AuditorClient {
	return &auditorClient{cc}
}

func (c *auditorClient) SubmitLogRoot(ctx context.Context, in *SubmitLogRootParams, opts ...grpc.CallOption) (*SubmitLogRootResponse, error) {
	out := new(SubmitLogRootResponse)
	err := c.cc.Invoke(ctx, "/vldmpb.Auditor/SubmitLogRoot", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *auditorClient) GetPeers(ctx context.Context, in *GetPeersParams, opts ...grpc.CallOption) (*GetPeersResponse, error) {
	out := new(GetPeersResponse)
	err := c.cc.Invoke(ctx, "/vldmpb.Auditor/GetPeers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AuditorServer is the server API for Auditor service.
type AuditorServer interface {
	SubmitLogRoot(context.Context, *SubmitLogRootParams) (*SubmitLogRootResponse, error)
	GetPeers(context.Context, *GetPeersParams) (*GetPeersResponse, error)
}

func RegisterAuditorServer(s *grpc.Server, srv AuditorServer) {
	s.RegisterService(&_Auditor_serviceDesc, srv)
}

func _Auditor_SubmitLogRoot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubmitLogRootParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AuditorServer).SubmitLogRoot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/vldmpb.Auditor/SubmitLogRoot",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AuditorServer).SubmitLogRoot(ctx, req.(*SubmitLogRootParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _Auditor_GetPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPeersParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AuditorServer).GetPeers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/vldmpb.Auditor/GetPeers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AuditorServer).GetPeers(ctx, req.(*GetPeersParams))
	}
	return interceptor(ctx, in, info, handler)
}

var _Auditor_serviceDesc = grpc.ServiceDesc{
	ServiceName: "vldmpb.Auditor",
	HandlerType: (*AuditorServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SubmitLogRoot",
			Handler:    _Auditor_SubmitLogRoot_Handler,
		},
		{
			MethodName: "GetPeers",
			Handler:    _Auditor_GetPeers_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "vldm.proto",
}

func init() { proto.RegisterFile("vldm.proto", fileDescriptor_vldm_3b8b12360bbba7f4) }

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