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

/*
Package trillian is a generated protocol buffer package.

It is generated from these files:
	trillian_log_api.proto
	trillian_map_api.proto
	trillian_admin_api.proto
	trillian.proto

It has these top-level messages:
	LogLeaf
	Proof
	QueuedLogLeaf
	QueueLeavesRequest
	QueueLeafRequest
	QueueLeafResponse
	QueueLeavesResponse
	GetInclusionProofRequest
	GetInclusionProofResponse
	GetInclusionProofByHashRequest
	GetInclusionProofByHashResponse
	GetConsistencyProofRequest
	GetConsistencyProofResponse
	GetLeavesByHashRequest
	GetLeavesByHashResponse
	GetLeavesByIndexRequest
	GetLeavesByIndexResponse
	GetSequencedLeafCountRequest
	GetSequencedLeafCountResponse
	GetLatestSignedLogRootRequest
	GetLatestSignedLogRootResponse
	GetEntryAndProofRequest
	GetEntryAndProofResponse
	MapLeaf
	MapLeafInclusion
	GetMapLeavesRequest
	GetMapLeavesResponse
	SetMapLeavesRequest
	SetMapLeavesResponse
	GetSignedMapRootRequest
	GetSignedMapRootByRevisionRequest
	GetSignedMapRootResponse
	ListTreesRequest
	ListTreesResponse
	GetTreeRequest
	CreateTreeRequest
	UpdateTreeRequest
	DeleteTreeRequest
	Tree
	SignedEntryTimestamp
	SignedLogRoot
	MapperMetadata
	SignedMapRoot
*/
package trillian

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_rpc "google.golang.org/genproto/googleapis/rpc/status"
import _ "google.golang.org/genproto/googleapis/api/annotations"

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 LogLeaf struct {
	// merkle_leaf_hash is over leaf data and optional extra_data.
	MerkleLeafHash []byte `protobuf:"bytes,1,opt,name=merkle_leaf_hash,json=merkleLeafHash,proto3" json:"merkle_leaf_hash,omitempty"`
	// leaf_value contains arbitrary data.
	LeafValue []byte `protobuf:"bytes,2,opt,name=leaf_value,json=leafValue,proto3" json:"leaf_value,omitempty"`
	// extra_data is optional metadata. e.g. a timestamp.
	ExtraData []byte `protobuf:"bytes,3,opt,name=extra_data,json=extraData,proto3" json:"extra_data,omitempty"`
	// leaf_index is optional. Trillian will assign the next available index when unset.
	// TODO: remove this into separate AddSequencedLeaves API.
	LeafIndex int64 `protobuf:"varint,4,opt,name=leaf_index,json=leafIndex" json:"leaf_index,omitempty"`
	// leaf_identity_hash is a hash over the identity of this leaf.
	// It's intended to provide a mechanism for the personality to provide a
	// hint to Trillian that two leaves should be considered "duplicates" even
	// though their leaf_values differ.
	//
	// E.g. in a CT personality multiple add-chain calls for an identical
	// certificate would produce differing leaf_data bytes (due to the presence
	// of SCT elements), with just this information Trillian would be unable to
	// determine that, within the context of the personality, these entries are
	// dupes, so the CT personality sets leaf_identity_hash to H(cert),
	// which allows Trillian to detect the duplicates.
	//
	// Continuing the CT example, for a CT mirror personality (which must allow
	// dupes since the source log could contain them), the part of the
	// personality which fetches and submits the entries might set
	// leaf_identity_hash to H(seq||certdata).
	LeafIdentityHash []byte `protobuf:"bytes,5,opt,name=leaf_identity_hash,json=leafIdentityHash,proto3" json:"leaf_identity_hash,omitempty"`
}

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

func (m *LogLeaf) GetMerkleLeafHash() []byte {
	if m != nil {
		return m.MerkleLeafHash
	}
	return nil
}

func (m *LogLeaf) GetLeafValue() []byte {
	if m != nil {
		return m.LeafValue
	}
	return nil
}

func (m *LogLeaf) GetExtraData() []byte {
	if m != nil {
		return m.ExtraData
	}
	return nil
}

func (m *LogLeaf) GetLeafIndex() int64 {
	if m != nil {
		return m.LeafIndex
	}
	return 0
}

func (m *LogLeaf) GetLeafIdentityHash() []byte {
	if m != nil {
		return m.LeafIdentityHash
	}
	return nil
}

type Proof struct {
	LeafIndex int64    `protobuf:"varint,1,opt,name=leaf_index,json=leafIndex" json:"leaf_index,omitempty"`
	Hashes    [][]byte `protobuf:"bytes,3,rep,name=hashes,proto3" json:"hashes,omitempty"`
}

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

func (m *Proof) GetLeafIndex() int64 {
	if m != nil {
		return m.LeafIndex
	}
	return 0
}

func (m *Proof) GetHashes() [][]byte {
	if m != nil {
		return m.Hashes
	}
	return nil
}

// QueuedLogLeaf represents a log leaf that has been queued for inclusion; it may
// be pending or already exist in the log (if the log does not allow duplicates).
type QueuedLogLeaf struct {
	// The leaf is present if status.code is:
	//  - google.rpc.OK : the leaf is the same as in the QueueLea{f,ves}Request
	//  - google.rpc.ALREADY_EXISTS : the leaf is the one already present in the log.
	Leaf   *LogLeaf           `protobuf:"bytes,1,opt,name=leaf" json:"leaf,omitempty"`
	Status *google_rpc.Status `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"`
}

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

func (m *QueuedLogLeaf) GetLeaf() *LogLeaf {
	if m != nil {
		return m.Leaf
	}
	return nil
}

func (m *QueuedLogLeaf) GetStatus() *google_rpc.Status {
	if m != nil {
		return m.Status
	}
	return nil
}

type QueueLeavesRequest struct {
	LogId  int64      `protobuf:"varint,1,opt,name=log_id,json=logId" json:"log_id,omitempty"`
	Leaves []*LogLeaf `protobuf:"bytes,2,rep,name=leaves" json:"leaves,omitempty"`
}

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

func (m *QueueLeavesRequest) GetLogId() int64 {
	if m != nil {
		return m.LogId
	}
	return 0
}

func (m *QueueLeavesRequest) GetLeaves() []*LogLeaf {
	if m != nil {
		return m.Leaves
	}
	return nil
}

type QueueLeafRequest struct {
	LogId int64    `protobuf:"varint,1,opt,name=log_id,json=logId" json:"log_id,omitempty"`
	Leaf  *LogLeaf `protobuf:"bytes,2,opt,name=leaf" json:"leaf,omitempty"`
}

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

func (m *QueueLeafRequest) GetLogId() int64 {
	if m != nil {
		return m.LogId
	}
	return 0
}

func (m *QueueLeafRequest) GetLeaf() *LogLeaf {
	if m != nil {
		return m.Leaf
	}
	return nil
}

type QueueLeafResponse struct {
	QueuedLeaf *QueuedLogLeaf `protobuf:"bytes,2,opt,name=queued_leaf,json=queuedLeaf" json:"queued_leaf,omitempty"`
}

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

func (m *QueueLeafResponse) GetQueuedLeaf() *QueuedLogLeaf {
	if m != nil {
		return m.QueuedLeaf
	}
	return nil
}

type QueueLeavesResponse struct {
	// Same number and order as in the corresponding request.
	QueuedLeaves []*QueuedLogLeaf `protobuf:"bytes,2,rep,name=queued_leaves,json=queuedLeaves" json:"queued_leaves,omitempty"`
}

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

func (m *QueueLeavesResponse) GetQueuedLeaves() []*QueuedLogLeaf {
	if m != nil {
		return m.QueuedLeaves
	}
	return nil
}

type GetInclusionProofRequest struct {
	LogId     int64 `protobuf:"varint,1,opt,name=log_id,json=logId" json:"log_id,omitempty"`
	LeafIndex int64 `protobuf:"varint,2,opt,name=leaf_index,json=leafIndex" json:"leaf_index,omitempty"`
	TreeSize  int64 `protobuf:"varint,3,opt,name=tree_size,json=treeSize" json:"tree_size,omitempty"`
}

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

func (m *GetInclusionProofRequest) GetLogId() int64 {
	if m != nil {
		return m.LogId
	}
	return 0
}

func (m *GetInclusionProofRequest) GetLeafIndex() int64 {
	if m != nil {
		return m.LeafIndex
	}
	return 0
}

func (m *GetInclusionProofRequest) GetTreeSize() int64 {
	if m != nil {
		return m.TreeSize
	}
	return 0
}

type GetInclusionProofResponse struct {
	Proof *Proof `protobuf:"bytes,2,opt,name=proof" json:"proof,omitempty"`
}

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

func (m *GetInclusionProofResponse) GetProof() *Proof {
	if m != nil {
		return m.Proof
	}
	return nil
}

type GetInclusionProofByHashRequest struct {
	LogId           int64  `protobuf:"varint,1,opt,name=log_id,json=logId" json:"log_id,omitempty"`
	LeafHash        []byte `protobuf:"bytes,2,opt,name=leaf_hash,json=leafHash,proto3" json:"leaf_hash,omitempty"`
	TreeSize        int64  `protobuf:"varint,3,opt,name=tree_size,json=treeSize" json:"tree_size,omitempty"`
	OrderBySequence bool   `protobuf:"varint,4,opt,name=order_by_sequence,json=orderBySequence" json:"order_by_sequence,omitempty"`
}

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

func (m *GetInclusionProofByHashRequest) GetLogId() int64 {
	if m != nil {
		return m.LogId
	}
	return 0
}

func (m *GetInclusionProofByHashRequest) GetLeafHash() []byte {
	if m != nil {
		return m.LeafHash
	}
	return nil
}

func (m *GetInclusionProofByHashRequest) GetTreeSize() int64 {
	if m != nil {
		return m.TreeSize
	}
	return 0
}

func (m *GetInclusionProofByHashRequest) GetOrderBySequence() bool {
	if m != nil {
		return m.OrderBySequence
	}
	return false
}

type GetInclusionProofByHashResponse struct {
	// Logs can potentially contain leaves with duplicate hashes so it's possible
	// for this to return multiple proofs.
	// TODO(gbelvin) only return one proof.
	Proof []*Proof `protobuf:"bytes,2,rep,name=proof" json:"proof,omitempty"`
}

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

func (m *GetInclusionProofByHashResponse) GetProof() []*Proof {
	if m != nil {
		return m.Proof
	}
	return nil
}

type GetConsistencyProofRequest struct {
	LogId          int64 `protobuf:"varint,1,opt,name=log_id,json=logId" json:"log_id,omitempty"`
	FirstTreeSize  int64 `protobuf:"varint,2,opt,name=first_tree_size,json=firstTreeSize" json:"first_tree_size,omitempty"`
	SecondTreeSize int64 `protobuf:"varint,3,opt,name=second_tree_size,json=secondTreeSize" json:"second_tree_size,omitempty"`
}

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

func (m *GetConsistencyProofRequest) GetLogId() int64 {
	if m != nil {
		return m.LogId
	}
	return 0
}

func (m *GetConsistencyProofRequest) GetFirstTreeSize() int64 {
	if m != nil {
		return m.FirstTreeSize
	}
	return 0
}

func (m *GetConsistencyProofRequest) GetSecondTreeSize() int64 {
	if m != nil {
		return m.SecondTreeSize
	}
	return 0
}

type GetConsistencyProofResponse struct {
	Proof *Proof `protobuf:"bytes,2,opt,name=proof" json:"proof,omitempty"`
}

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

func (m *GetConsistencyProofResponse) GetProof() *Proof {
	if m != nil {
		return m.Proof
	}
	return nil
}

type GetLeavesByHashRequest struct {
	LogId           int64    `protobuf:"varint,1,opt,name=log_id,json=logId" json:"log_id,omitempty"`
	LeafHash        [][]byte `protobuf:"bytes,2,rep,name=leaf_hash,json=leafHash,proto3" json:"leaf_hash,omitempty"`
	OrderBySequence bool     `protobuf:"varint,3,opt,name=order_by_sequence,json=orderBySequence" json:"order_by_sequence,omitempty"`
}

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

func (m *GetLeavesByHashRequest) GetLogId() int64 {
	if m != nil {
		return m.LogId
	}
	return 0
}

func (m *GetLeavesByHashRequest) GetLeafHash() [][]byte {
	if m != nil {
		return m.LeafHash
	}
	return nil
}

func (m *GetLeavesByHashRequest) GetOrderBySequence() bool {
	if m != nil {
		return m.OrderBySequence
	}
	return false
}

type GetLeavesByHashResponse struct {
	// TODO(gbelvin) reply with error codes.
	Leaves []*LogLeaf `protobuf:"bytes,2,rep,name=leaves" json:"leaves,omitempty"`
}

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

func (m *GetLeavesByHashResponse) GetLeaves() []*LogLeaf {
	if m != nil {
		return m.Leaves
	}
	return nil
}

type GetLeavesByIndexRequest struct {
	LogId     int64   `protobuf:"varint,1,opt,name=log_id,json=logId" json:"log_id,omitempty"`
	LeafIndex []int64 `protobuf:"varint,2,rep,packed,name=leaf_index,json=leafIndex" json:"leaf_index,omitempty"`
}

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

func (m *GetLeavesByIndexRequest) GetLogId() int64 {
	if m != nil {
		return m.LogId
	}
	return 0
}

func (m *GetLeavesByIndexRequest) GetLeafIndex() []int64 {
	if m != nil {
		return m.LeafIndex
	}
	return nil
}

type GetLeavesByIndexResponse struct {
	// TODO(gbelvin) reply with error codes.
	Leaves []*LogLeaf `protobuf:"bytes,2,rep,name=leaves" json:"leaves,omitempty"`
}

func (m *GetLeavesByIndexResponse) Reset()                    { *m = GetLeavesByIndexResponse{} }
func (m *GetLeavesByIndexResponse) String() string            { return proto.CompactTextString(m) }
func (*GetLeavesByIndexResponse) ProtoMessage()               {}
func (*GetLeavesByIndexResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }

func (m *GetLeavesByIndexResponse) GetLeaves() []*LogLeaf {
	if m != nil {
		return m.Leaves
	}
	return nil
}

type GetSequencedLeafCountRequest struct {
	LogId int64 `protobuf:"varint,1,opt,name=log_id,json=logId" json:"log_id,omitempty"`
}

func (m *GetSequencedLeafCountRequest) Reset()                    { *m = GetSequencedLeafCountRequest{} }
func (m *GetSequencedLeafCountRequest) String() string            { return proto.CompactTextString(m) }
func (*GetSequencedLeafCountRequest) ProtoMessage()               {}
func (*GetSequencedLeafCountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }

func (m *GetSequencedLeafCountRequest) GetLogId() int64 {
	if m != nil {
		return m.LogId
	}
	return 0
}

type GetSequencedLeafCountResponse struct {
	LeafCount int64 `protobuf:"varint,2,opt,name=leaf_count,json=leafCount" json:"leaf_count,omitempty"`
}

func (m *GetSequencedLeafCountResponse) Reset()                    { *m = GetSequencedLeafCountResponse{} }
func (m *GetSequencedLeafCountResponse) String() string            { return proto.CompactTextString(m) }
func (*GetSequencedLeafCountResponse) ProtoMessage()               {}
func (*GetSequencedLeafCountResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }

func (m *GetSequencedLeafCountResponse) GetLeafCount() int64 {
	if m != nil {
		return m.LeafCount
	}
	return 0
}

type GetLatestSignedLogRootRequest struct {
	LogId int64 `protobuf:"varint,1,opt,name=log_id,json=logId" json:"log_id,omitempty"`
}

func (m *GetLatestSignedLogRootRequest) Reset()                    { *m = GetLatestSignedLogRootRequest{} }
func (m *GetLatestSignedLogRootRequest) String() string            { return proto.CompactTextString(m) }
func (*GetLatestSignedLogRootRequest) ProtoMessage()               {}
func (*GetLatestSignedLogRootRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }

func (m *GetLatestSignedLogRootRequest) GetLogId() int64 {
	if m != nil {
		return m.LogId
	}
	return 0
}

type GetLatestSignedLogRootResponse struct {
	SignedLogRoot *SignedLogRoot `protobuf:"bytes,2,opt,name=signed_log_root,json=signedLogRoot" json:"signed_log_root,omitempty"`
}

func (m *GetLatestSignedLogRootResponse) Reset()                    { *m = GetLatestSignedLogRootResponse{} }
func (m *GetLatestSignedLogRootResponse) String() string            { return proto.CompactTextString(m) }
func (*GetLatestSignedLogRootResponse) ProtoMessage()               {}
func (*GetLatestSignedLogRootResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }

func (m *GetLatestSignedLogRootResponse) GetSignedLogRoot() *SignedLogRoot {
	if m != nil {
		return m.SignedLogRoot
	}
	return nil
}

type GetEntryAndProofRequest struct {
	LogId     int64 `protobuf:"varint,1,opt,name=log_id,json=logId" json:"log_id,omitempty"`
	LeafIndex int64 `protobuf:"varint,2,opt,name=leaf_index,json=leafIndex" json:"leaf_index,omitempty"`
	TreeSize  int64 `protobuf:"varint,3,opt,name=tree_size,json=treeSize" json:"tree_size,omitempty"`
}

func (m *GetEntryAndProofRequest) Reset()                    { *m = GetEntryAndProofRequest{} }
func (m *GetEntryAndProofRequest) String() string            { return proto.CompactTextString(m) }
func (*GetEntryAndProofRequest) ProtoMessage()               {}
func (*GetEntryAndProofRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }

func (m *GetEntryAndProofRequest) GetLogId() int64 {
	if m != nil {
		return m.LogId
	}
	return 0
}

func (m *GetEntryAndProofRequest) GetLeafIndex() int64 {
	if m != nil {
		return m.LeafIndex
	}
	return 0
}

func (m *GetEntryAndProofRequest) GetTreeSize() int64 {
	if m != nil {
		return m.TreeSize
	}
	return 0
}

type GetEntryAndProofResponse struct {
	Proof *Proof   `protobuf:"bytes,2,opt,name=proof" json:"proof,omitempty"`
	Leaf  *LogLeaf `protobuf:"bytes,3,opt,name=leaf" json:"leaf,omitempty"`
}

func (m *GetEntryAndProofResponse) Reset()                    { *m = GetEntryAndProofResponse{} }
func (m *GetEntryAndProofResponse) String() string            { return proto.CompactTextString(m) }
func (*GetEntryAndProofResponse) ProtoMessage()               {}
func (*GetEntryAndProofResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }

func (m *GetEntryAndProofResponse) GetProof() *Proof {
	if m != nil {
		return m.Proof
	}
	return nil
}

func (m *GetEntryAndProofResponse) GetLeaf() *LogLeaf {
	if m != nil {
		return m.Leaf
	}
	return nil
}

func init() {
	proto.RegisterType((*LogLeaf)(nil), "trillian.LogLeaf")
	proto.RegisterType((*Proof)(nil), "trillian.Proof")
	proto.RegisterType((*QueuedLogLeaf)(nil), "trillian.QueuedLogLeaf")
	proto.RegisterType((*QueueLeavesRequest)(nil), "trillian.QueueLeavesRequest")
	proto.RegisterType((*QueueLeafRequest)(nil), "trillian.QueueLeafRequest")
	proto.RegisterType((*QueueLeafResponse)(nil), "trillian.QueueLeafResponse")
	proto.RegisterType((*QueueLeavesResponse)(nil), "trillian.QueueLeavesResponse")
	proto.RegisterType((*GetInclusionProofRequest)(nil), "trillian.GetInclusionProofRequest")
	proto.RegisterType((*GetInclusionProofResponse)(nil), "trillian.GetInclusionProofResponse")
	proto.RegisterType((*GetInclusionProofByHashRequest)(nil), "trillian.GetInclusionProofByHashRequest")
	proto.RegisterType((*GetInclusionProofByHashResponse)(nil), "trillian.GetInclusionProofByHashResponse")
	proto.RegisterType((*GetConsistencyProofRequest)(nil), "trillian.GetConsistencyProofRequest")
	proto.RegisterType((*GetConsistencyProofResponse)(nil), "trillian.GetConsistencyProofResponse")
	proto.RegisterType((*GetLeavesByHashRequest)(nil), "trillian.GetLeavesByHashRequest")
	proto.RegisterType((*GetLeavesByHashResponse)(nil), "trillian.GetLeavesByHashResponse")
	proto.RegisterType((*GetLeavesByIndexRequest)(nil), "trillian.GetLeavesByIndexRequest")
	proto.RegisterType((*GetLeavesByIndexResponse)(nil), "trillian.GetLeavesByIndexResponse")
	proto.RegisterType((*GetSequencedLeafCountRequest)(nil), "trillian.GetSequencedLeafCountRequest")
	proto.RegisterType((*GetSequencedLeafCountResponse)(nil), "trillian.GetSequencedLeafCountResponse")
	proto.RegisterType((*GetLatestSignedLogRootRequest)(nil), "trillian.GetLatestSignedLogRootRequest")
	proto.RegisterType((*GetLatestSignedLogRootResponse)(nil), "trillian.GetLatestSignedLogRootResponse")
	proto.RegisterType((*GetEntryAndProofRequest)(nil), "trillian.GetEntryAndProofRequest")
	proto.RegisterType((*GetEntryAndProofResponse)(nil), "trillian.GetEntryAndProofResponse")
}

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

type TrillianLogClient interface {
	// QueueLeaf adds a single leaf to the queue.
	QueueLeaf(ctx context.Context, in *QueueLeafRequest, opts ...grpc.CallOption) (*QueueLeafResponse, error)
	// No direct equivalent at the storage level
	GetInclusionProof(ctx context.Context, in *GetInclusionProofRequest, opts ...grpc.CallOption) (*GetInclusionProofResponse, error)
	GetInclusionProofByHash(ctx context.Context, in *GetInclusionProofByHashRequest, opts ...grpc.CallOption) (*GetInclusionProofByHashResponse, error)
	GetConsistencyProof(ctx context.Context, in *GetConsistencyProofRequest, opts ...grpc.CallOption) (*GetConsistencyProofResponse, error)
	// Corresponds to the LogRootReader API
	GetLatestSignedLogRoot(ctx context.Context, in *GetLatestSignedLogRootRequest, opts ...grpc.CallOption) (*GetLatestSignedLogRootResponse, error)
	// Corresponds to the LeafReader API
	GetSequencedLeafCount(ctx context.Context, in *GetSequencedLeafCountRequest, opts ...grpc.CallOption) (*GetSequencedLeafCountResponse, error)
	GetEntryAndProof(ctx context.Context, in *GetEntryAndProofRequest, opts ...grpc.CallOption) (*GetEntryAndProofResponse, error)
	// Corresponds to the LeafQueuer API
	QueueLeaves(ctx context.Context, in *QueueLeavesRequest, opts ...grpc.CallOption) (*QueueLeavesResponse, error)
	GetLeavesByIndex(ctx context.Context, in *GetLeavesByIndexRequest, opts ...grpc.CallOption) (*GetLeavesByIndexResponse, error)
	GetLeavesByHash(ctx context.Context, in *GetLeavesByHashRequest, opts ...grpc.CallOption) (*GetLeavesByHashResponse, error)
}

type trillianLogClient struct {
	cc *grpc.ClientConn
}

func NewTrillianLogClient(cc *grpc.ClientConn) TrillianLogClient {
	return &trillianLogClient{cc}
}

func (c *trillianLogClient) QueueLeaf(ctx context.Context, in *QueueLeafRequest, opts ...grpc.CallOption) (*QueueLeafResponse, error) {
	out := new(QueueLeafResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/QueueLeaf", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *trillianLogClient) GetInclusionProof(ctx context.Context, in *GetInclusionProofRequest, opts ...grpc.CallOption) (*GetInclusionProofResponse, error) {
	out := new(GetInclusionProofResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/GetInclusionProof", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *trillianLogClient) GetInclusionProofByHash(ctx context.Context, in *GetInclusionProofByHashRequest, opts ...grpc.CallOption) (*GetInclusionProofByHashResponse, error) {
	out := new(GetInclusionProofByHashResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/GetInclusionProofByHash", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *trillianLogClient) GetConsistencyProof(ctx context.Context, in *GetConsistencyProofRequest, opts ...grpc.CallOption) (*GetConsistencyProofResponse, error) {
	out := new(GetConsistencyProofResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/GetConsistencyProof", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *trillianLogClient) GetLatestSignedLogRoot(ctx context.Context, in *GetLatestSignedLogRootRequest, opts ...grpc.CallOption) (*GetLatestSignedLogRootResponse, error) {
	out := new(GetLatestSignedLogRootResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/GetLatestSignedLogRoot", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *trillianLogClient) GetSequencedLeafCount(ctx context.Context, in *GetSequencedLeafCountRequest, opts ...grpc.CallOption) (*GetSequencedLeafCountResponse, error) {
	out := new(GetSequencedLeafCountResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/GetSequencedLeafCount", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *trillianLogClient) GetEntryAndProof(ctx context.Context, in *GetEntryAndProofRequest, opts ...grpc.CallOption) (*GetEntryAndProofResponse, error) {
	out := new(GetEntryAndProofResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/GetEntryAndProof", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *trillianLogClient) QueueLeaves(ctx context.Context, in *QueueLeavesRequest, opts ...grpc.CallOption) (*QueueLeavesResponse, error) {
	out := new(QueueLeavesResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/QueueLeaves", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *trillianLogClient) GetLeavesByIndex(ctx context.Context, in *GetLeavesByIndexRequest, opts ...grpc.CallOption) (*GetLeavesByIndexResponse, error) {
	out := new(GetLeavesByIndexResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/GetLeavesByIndex", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *trillianLogClient) GetLeavesByHash(ctx context.Context, in *GetLeavesByHashRequest, opts ...grpc.CallOption) (*GetLeavesByHashResponse, error) {
	out := new(GetLeavesByHashResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/GetLeavesByHash", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for TrillianLog service

type TrillianLogServer interface {
	// QueueLeaf adds a single leaf to the queue.
	QueueLeaf(context.Context, *QueueLeafRequest) (*QueueLeafResponse, error)
	// No direct equivalent at the storage level
	GetInclusionProof(context.Context, *GetInclusionProofRequest) (*GetInclusionProofResponse, error)
	GetInclusionProofByHash(context.Context, *GetInclusionProofByHashRequest) (*GetInclusionProofByHashResponse, error)
	GetConsistencyProof(context.Context, *GetConsistencyProofRequest) (*GetConsistencyProofResponse, error)
	// Corresponds to the LogRootReader API
	GetLatestSignedLogRoot(context.Context, *GetLatestSignedLogRootRequest) (*GetLatestSignedLogRootResponse, error)
	// Corresponds to the LeafReader API
	GetSequencedLeafCount(context.Context, *GetSequencedLeafCountRequest) (*GetSequencedLeafCountResponse, error)
	GetEntryAndProof(context.Context, *GetEntryAndProofRequest) (*GetEntryAndProofResponse, error)
	// Corresponds to the LeafQueuer API
	QueueLeaves(context.Context, *QueueLeavesRequest) (*QueueLeavesResponse, error)
	GetLeavesByIndex(context.Context, *GetLeavesByIndexRequest) (*GetLeavesByIndexResponse, error)
	GetLeavesByHash(context.Context, *GetLeavesByHashRequest) (*GetLeavesByHashResponse, error)
}

func RegisterTrillianLogServer(s *grpc.Server, srv TrillianLogServer) {
	s.RegisterService(&_TrillianLog_serviceDesc, srv)
}

func _TrillianLog_QueueLeaf_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueueLeafRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).QueueLeaf(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/QueueLeaf",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).QueueLeaf(ctx, req.(*QueueLeafRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TrillianLog_GetInclusionProof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInclusionProofRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).GetInclusionProof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/GetInclusionProof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).GetInclusionProof(ctx, req.(*GetInclusionProofRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TrillianLog_GetInclusionProofByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInclusionProofByHashRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).GetInclusionProofByHash(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/GetInclusionProofByHash",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).GetInclusionProofByHash(ctx, req.(*GetInclusionProofByHashRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TrillianLog_GetConsistencyProof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetConsistencyProofRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).GetConsistencyProof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/GetConsistencyProof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).GetConsistencyProof(ctx, req.(*GetConsistencyProofRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TrillianLog_GetLatestSignedLogRoot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLatestSignedLogRootRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).GetLatestSignedLogRoot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/GetLatestSignedLogRoot",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).GetLatestSignedLogRoot(ctx, req.(*GetLatestSignedLogRootRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TrillianLog_GetSequencedLeafCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSequencedLeafCountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).GetSequencedLeafCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/GetSequencedLeafCount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).GetSequencedLeafCount(ctx, req.(*GetSequencedLeafCountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TrillianLog_GetEntryAndProof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetEntryAndProofRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).GetEntryAndProof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/GetEntryAndProof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).GetEntryAndProof(ctx, req.(*GetEntryAndProofRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TrillianLog_QueueLeaves_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueueLeavesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).QueueLeaves(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/QueueLeaves",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).QueueLeaves(ctx, req.(*QueueLeavesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TrillianLog_GetLeavesByIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLeavesByIndexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).GetLeavesByIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/GetLeavesByIndex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).GetLeavesByIndex(ctx, req.(*GetLeavesByIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TrillianLog_GetLeavesByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLeavesByHashRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).GetLeavesByHash(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/GetLeavesByHash",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).GetLeavesByHash(ctx, req.(*GetLeavesByHashRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _TrillianLog_serviceDesc = grpc.ServiceDesc{
	ServiceName: "trillian.TrillianLog",
	HandlerType: (*TrillianLogServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "QueueLeaf",
			Handler:    _TrillianLog_QueueLeaf_Handler,
		},
		{
			MethodName: "GetInclusionProof",
			Handler:    _TrillianLog_GetInclusionProof_Handler,
		},
		{
			MethodName: "GetInclusionProofByHash",
			Handler:    _TrillianLog_GetInclusionProofByHash_Handler,
		},
		{
			MethodName: "GetConsistencyProof",
			Handler:    _TrillianLog_GetConsistencyProof_Handler,
		},
		{
			MethodName: "GetLatestSignedLogRoot",
			Handler:    _TrillianLog_GetLatestSignedLogRoot_Handler,
		},
		{
			MethodName: "GetSequencedLeafCount",
			Handler:    _TrillianLog_GetSequencedLeafCount_Handler,
		},
		{
			MethodName: "GetEntryAndProof",
			Handler:    _TrillianLog_GetEntryAndProof_Handler,
		},
		{
			MethodName: "QueueLeaves",
			Handler:    _TrillianLog_QueueLeaves_Handler,
		},
		{
			MethodName: "GetLeavesByIndex",
			Handler:    _TrillianLog_GetLeavesByIndex_Handler,
		},
		{
			MethodName: "GetLeavesByHash",
			Handler:    _TrillianLog_GetLeavesByHash_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "trillian_log_api.proto",
}

func init() { proto.RegisterFile("trillian_log_api.proto", fileDescriptor0) }

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