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

/*
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:
	QueueLeafRequest
	QueueLeafResponse
	AddSequencedLeafRequest
	AddSequencedLeafResponse
	GetInclusionProofRequest
	GetInclusionProofResponse
	GetInclusionProofByHashRequest
	GetInclusionProofByHashResponse
	GetConsistencyProofRequest
	GetConsistencyProofResponse
	GetLatestSignedLogRootRequest
	GetLatestSignedLogRootResponse
	GetSequencedLeafCountRequest
	GetSequencedLeafCountResponse
	GetEntryAndProofRequest
	GetEntryAndProofResponse
	InitLogRequest
	InitLogResponse
	QueueLeavesRequest
	QueueLeavesResponse
	AddSequencedLeavesRequest
	AddSequencedLeavesResponse
	GetLeavesByIndexRequest
	GetLeavesByIndexResponse
	GetLeavesByRangeRequest
	GetLeavesByRangeResponse
	GetLeavesByHashRequest
	GetLeavesByHashResponse
	QueuedLogLeaf
	LogLeaf
	Proof
	MapLeaf
	MapLeafInclusion
	GetMapLeavesRequest
	GetMapLeavesByRevisionRequest
	GetMapLeavesResponse
	SetMapLeavesRequest
	SetMapLeavesResponse
	GetSignedMapRootRequest
	GetSignedMapRootByRevisionRequest
	GetSignedMapRootResponse
	InitMapRequest
	InitMapResponse
	ListTreesRequest
	ListTreesResponse
	GetTreeRequest
	CreateTreeRequest
	UpdateTreeRequest
	DeleteTreeRequest
	UndeleteTreeRequest
	Tree
	SignedEntryTimestamp
	SignedLogRoot
	SignedMapRoot
*/
package trillian

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

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 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{0} }

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{1} }

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

type AddSequencedLeafRequest 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 *AddSequencedLeafRequest) Reset()                    { *m = AddSequencedLeafRequest{} }
func (m *AddSequencedLeafRequest) String() string            { return proto.CompactTextString(m) }
func (*AddSequencedLeafRequest) ProtoMessage()               {}
func (*AddSequencedLeafRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

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

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

type AddSequencedLeafResponse struct {
	Result *QueuedLogLeaf `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"`
}

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

func (m *AddSequencedLeafResponse) GetResult() *QueuedLogLeaf {
	if m != nil {
		return m.Result
	}
	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{4} }

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"`
	SignedLogRoot *SignedLogRoot `protobuf:"bytes,3,opt,name=signed_log_root,json=signedLogRoot" json:"signed_log_root,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{5} }

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

func (m *GetInclusionProofResponse) GetSignedLogRoot() *SignedLogRoot {
	if m != nil {
		return m.SignedLogRoot
	}
	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{6} }

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"`
	SignedLogRoot *SignedLogRoot `protobuf:"bytes,3,opt,name=signed_log_root,json=signedLogRoot" json:"signed_log_root,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{7} }

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

func (m *GetInclusionProofByHashResponse) GetSignedLogRoot() *SignedLogRoot {
	if m != nil {
		return m.SignedLogRoot
	}
	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{8} }

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"`
	SignedLogRoot *SignedLogRoot `protobuf:"bytes,3,opt,name=signed_log_root,json=signedLogRoot" json:"signed_log_root,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{9} }

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

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

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{10} }

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{11} }

func (m *GetLatestSignedLogRootResponse) GetSignedLogRoot() *SignedLogRoot {
	if m != nil {
		return m.SignedLogRoot
	}
	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{12} }

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{13} }

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

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{14} }

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"`
	SignedLogRoot *SignedLogRoot `protobuf:"bytes,4,opt,name=signed_log_root,json=signedLogRoot" json:"signed_log_root,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{15} }

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 (m *GetEntryAndProofResponse) GetSignedLogRoot() *SignedLogRoot {
	if m != nil {
		return m.SignedLogRoot
	}
	return nil
}

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

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

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

type InitLogResponse struct {
	Created *SignedLogRoot `protobuf:"bytes,1,opt,name=created" json:"created,omitempty"`
}

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

func (m *InitLogResponse) GetCreated() *SignedLogRoot {
	if m != nil {
		return m.Created
	}
	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{18} }

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 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{19} }

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

type AddSequencedLeavesRequest 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 *AddSequencedLeavesRequest) Reset()                    { *m = AddSequencedLeavesRequest{} }
func (m *AddSequencedLeavesRequest) String() string            { return proto.CompactTextString(m) }
func (*AddSequencedLeavesRequest) ProtoMessage()               {}
func (*AddSequencedLeavesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }

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

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

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

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

func (m *AddSequencedLeavesResponse) GetResults() []*QueuedLogLeaf {
	if m != nil {
		return m.Results
	}
	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{22} }

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. Reuse QueuedLogLeaf?
	Leaves        []*LogLeaf     `protobuf:"bytes,2,rep,name=leaves" json:"leaves,omitempty"`
	SignedLogRoot *SignedLogRoot `protobuf:"bytes,3,opt,name=signed_log_root,json=signedLogRoot" json:"signed_log_root,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{23} }

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

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

type GetLeavesByRangeRequest struct {
	LogId      int64 `protobuf:"varint,1,opt,name=log_id,json=logId" json:"log_id,omitempty"`
	StartIndex int64 `protobuf:"varint,2,opt,name=start_index,json=startIndex" json:"start_index,omitempty"`
	Count      int64 `protobuf:"varint,3,opt,name=count" json:"count,omitempty"`
}

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

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

func (m *GetLeavesByRangeRequest) GetStartIndex() int64 {
	if m != nil {
		return m.StartIndex
	}
	return 0
}

func (m *GetLeavesByRangeRequest) GetCount() int64 {
	if m != nil {
		return m.Count
	}
	return 0
}

type GetLeavesByRangeResponse struct {
	// Returned log leaves starting from the `start_index` of the request, in
	// order. There may be fewer than `request.count` leaves returned, if the
	// requested range extended beyond the size of the tree or if the server opted
	// to return fewer leaves than requested.
	Leaves        []*LogLeaf     `protobuf:"bytes,1,rep,name=leaves" json:"leaves,omitempty"`
	SignedLogRoot *SignedLogRoot `protobuf:"bytes,2,opt,name=signed_log_root,json=signedLogRoot" json:"signed_log_root,omitempty"`
}

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

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

func (m *GetLeavesByRangeResponse) GetSignedLogRoot() *SignedLogRoot {
	if m != nil {
		return m.SignedLogRoot
	}
	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{26} }

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. Reuse QueuedLogLeaf?
	Leaves        []*LogLeaf     `protobuf:"bytes,2,rep,name=leaves" json:"leaves,omitempty"`
	SignedLogRoot *SignedLogRoot `protobuf:"bytes,3,opt,name=signed_log_root,json=signedLogRoot" json:"signed_log_root,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{27} }

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

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

// A result of submitting an entry to the log. Output only.
// TODO(pavelkalinnikov): Consider renaming it to AddLogLeafResult or the like.
type QueuedLogLeaf struct {
	// The leaf as it was stored by Trillian. Empty unless `status.code` is:
	//  - `google.rpc.OK`: the `leaf` data is the same as in the request.
	//  - `google.rpc.ALREADY_EXISTS` or 'google.rpc.FAILED_PRECONDITION`: the
	//    `leaf` is the conflicting one already in the log.
	Leaf *LogLeaf `protobuf:"bytes,1,opt,name=leaf" json:"leaf,omitempty"`
	// The status of adding the leaf.
	//  - `google.rpc.OK`: successfully added.
	//  - `google.rpc.ALREADY_EXISTS`: the leaf is a duplicate of an already
	//    existing one. Either `leaf_identity_hash` is the same in the `LOG`
	//    mode, or `leaf_index` in the `PREORDERED_LOG`.
	//  - `google.rpc.FAILED_PRECONDITION`: A conflicting entry is already
	//    present in the log, e.g., same `leaf_index` but different `leaf_data`.
	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{28} }

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
}

// A leaf of the log's Merkle tree, corresponds to a single log entry. Each leaf
// has a unique `leaf_index` in the scope of this tree.
type LogLeaf struct {
	// Output only. The hash over `leaf_data`.
	MerkleLeafHash []byte `protobuf:"bytes,1,opt,name=merkle_leaf_hash,json=merkleLeafHash,proto3" json:"merkle_leaf_hash,omitempty"`
	// Required. The arbitrary data associated with this log entry. Validity of
	// this field is governed by the call site (personality).
	LeafValue []byte `protobuf:"bytes,2,opt,name=leaf_value,json=leafValue,proto3" json:"leaf_value,omitempty"`
	// The arbitrary metadata, e.g., a timestamp.
	ExtraData []byte `protobuf:"bytes,3,opt,name=extra_data,json=extraData,proto3" json:"extra_data,omitempty"`
	// Output only in `LOG` mode. Required in `PREORDERED_LOG` mode.
	// The index of the leaf in the Merkle tree, i.e., the position of the
	// corresponding entry in the log. For normal logs this value will be
	// assigned by the LogSigner.
	LeafIndex int64 `protobuf:"varint,4,opt,name=leaf_index,json=leafIndex" json:"leaf_index,omitempty"`
	// The hash over the identity of this leaf. If empty, assumed to be the same
	// as `merkle_leaf_hash`. It is a mechanism for the personality to provide a
	// hint to Trillian that two leaves should be considered "duplicates" even
	// though their `leaf_value`s 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 CT personality, these
	// entries are dupes, so it 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(leaf_index||cert)`.
	// TODO(pavelkalinnikov): Consider instead using `H(cert)` and allowing
	// identity hash dupes in `PREORDERED_LOG` mode, for it can later be
	// upgraded to `LOG` which will need to correctly detect duplicates with
	// older entries when new ones get queued.
	LeafIdentityHash []byte `protobuf:"bytes,5,opt,name=leaf_identity_hash,json=leafIdentityHash,proto3" json:"leaf_identity_hash,omitempty"`
	// Output only. The time at which this leaf was passed to `QueueLeaves`.
	// This value will be determined and set by the LogServer. Equals zero if
	// the entry was submitted without queuing.
	QueueTimestamp *google_protobuf1.Timestamp `protobuf:"bytes,6,opt,name=queue_timestamp,json=queueTimestamp" json:"queue_timestamp,omitempty"`
	// Output only. The time at which this leaf was integrated into the tree.
	// This value will be determined and set by the LogSigner.
	IntegrateTimestamp *google_protobuf1.Timestamp `protobuf:"bytes,7,opt,name=integrate_timestamp,json=integrateTimestamp" json:"integrate_timestamp,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{29} }

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
}

func (m *LogLeaf) GetQueueTimestamp() *google_protobuf1.Timestamp {
	if m != nil {
		return m.QueueTimestamp
	}
	return nil
}

func (m *LogLeaf) GetIntegrateTimestamp() *google_protobuf1.Timestamp {
	if m != nil {
		return m.IntegrateTimestamp
	}
	return nil
}

// A consistency or inclusion proof for a Merkle tree. Output only.
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{30} }

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
}

func init() {
	proto.RegisterType((*QueueLeafRequest)(nil), "trillian.QueueLeafRequest")
	proto.RegisterType((*QueueLeafResponse)(nil), "trillian.QueueLeafResponse")
	proto.RegisterType((*AddSequencedLeafRequest)(nil), "trillian.AddSequencedLeafRequest")
	proto.RegisterType((*AddSequencedLeafResponse)(nil), "trillian.AddSequencedLeafResponse")
	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((*GetLatestSignedLogRootRequest)(nil), "trillian.GetLatestSignedLogRootRequest")
	proto.RegisterType((*GetLatestSignedLogRootResponse)(nil), "trillian.GetLatestSignedLogRootResponse")
	proto.RegisterType((*GetSequencedLeafCountRequest)(nil), "trillian.GetSequencedLeafCountRequest")
	proto.RegisterType((*GetSequencedLeafCountResponse)(nil), "trillian.GetSequencedLeafCountResponse")
	proto.RegisterType((*GetEntryAndProofRequest)(nil), "trillian.GetEntryAndProofRequest")
	proto.RegisterType((*GetEntryAndProofResponse)(nil), "trillian.GetEntryAndProofResponse")
	proto.RegisterType((*InitLogRequest)(nil), "trillian.InitLogRequest")
	proto.RegisterType((*InitLogResponse)(nil), "trillian.InitLogResponse")
	proto.RegisterType((*QueueLeavesRequest)(nil), "trillian.QueueLeavesRequest")
	proto.RegisterType((*QueueLeavesResponse)(nil), "trillian.QueueLeavesResponse")
	proto.RegisterType((*AddSequencedLeavesRequest)(nil), "trillian.AddSequencedLeavesRequest")
	proto.RegisterType((*AddSequencedLeavesResponse)(nil), "trillian.AddSequencedLeavesResponse")
	proto.RegisterType((*GetLeavesByIndexRequest)(nil), "trillian.GetLeavesByIndexRequest")
	proto.RegisterType((*GetLeavesByIndexResponse)(nil), "trillian.GetLeavesByIndexResponse")
	proto.RegisterType((*GetLeavesByRangeRequest)(nil), "trillian.GetLeavesByRangeRequest")
	proto.RegisterType((*GetLeavesByRangeResponse)(nil), "trillian.GetLeavesByRangeResponse")
	proto.RegisterType((*GetLeavesByHashRequest)(nil), "trillian.GetLeavesByHashRequest")
	proto.RegisterType((*GetLeavesByHashResponse)(nil), "trillian.GetLeavesByHashResponse")
	proto.RegisterType((*QueuedLogLeaf)(nil), "trillian.QueuedLogLeaf")
	proto.RegisterType((*LogLeaf)(nil), "trillian.LogLeaf")
	proto.RegisterType((*Proof)(nil), "trillian.Proof")
}

// 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 {
	// Adds a single leaf to the queue.
	QueueLeaf(ctx context.Context, in *QueueLeafRequest, opts ...grpc.CallOption) (*QueueLeafResponse, error)
	// Adds a single leaf with an assigned sequence number.
	// Warning: This RPC is under development, don't use it.
	AddSequencedLeaf(ctx context.Context, in *AddSequencedLeafRequest, opts ...grpc.CallOption) (*AddSequencedLeafResponse, error)
	// Returns inclusion proof for a leaf with a given index in a given tree.
	GetInclusionProof(ctx context.Context, in *GetInclusionProofRequest, opts ...grpc.CallOption) (*GetInclusionProofResponse, error)
	// Returns inclusion proof for a leaf with a given identity hash in a given
	// tree.
	GetInclusionProofByHash(ctx context.Context, in *GetInclusionProofByHashRequest, opts ...grpc.CallOption) (*GetInclusionProofByHashResponse, error)
	// Returns consistency proof between two versions of a given tree.
	GetConsistencyProof(ctx context.Context, in *GetConsistencyProofRequest, opts ...grpc.CallOption) (*GetConsistencyProofResponse, error)
	// Returns the latest signed log root for a given tree. Corresponds to the
	// ReadOnlyLogTreeTX.LatestSignedLogRoot storage interface.
	GetLatestSignedLogRoot(ctx context.Context, in *GetLatestSignedLogRootRequest, opts ...grpc.CallOption) (*GetLatestSignedLogRootResponse, error)
	// Returns the total number of leaves that have been integrated into the
	// given tree. Corresponds to the ReadOnlyLogTreeTX.GetSequencedLeafCount
	// storage interface.
	// DO NOT USE - FOR DEBUGGING/TEST ONLY
	GetSequencedLeafCount(ctx context.Context, in *GetSequencedLeafCountRequest, opts ...grpc.CallOption) (*GetSequencedLeafCountResponse, error)
	// Returns log entry and the corresponding inclusion proof for a given leaf
	// index in a given tree. If the requested tree is unavailable but the leaf is in scope
	// for the current tree, return a proof in that tree instead.
	GetEntryAndProof(ctx context.Context, in *GetEntryAndProofRequest, opts ...grpc.CallOption) (*GetEntryAndProofResponse, error)
	InitLog(ctx context.Context, in *InitLogRequest, opts ...grpc.CallOption) (*InitLogResponse, error)
	// Adds a batch of leaves to the queue.
	QueueLeaves(ctx context.Context, in *QueueLeavesRequest, opts ...grpc.CallOption) (*QueueLeavesResponse, error)
	// Stores leaves from the provided batch and associates them with the log
	// positions according to the `LeafIndex` field. The indices must be
	// contiguous.
	//
	// Warning: This RPC is under development, don't use it.
	AddSequencedLeaves(ctx context.Context, in *AddSequencedLeavesRequest, opts ...grpc.CallOption) (*AddSequencedLeavesResponse, error)
	// Returns a batch of leaves located in the provided positions.
	GetLeavesByIndex(ctx context.Context, in *GetLeavesByIndexRequest, opts ...grpc.CallOption) (*GetLeavesByIndexResponse, error)
	// Returns a batch of leaves in a sequential range.
	GetLeavesByRange(ctx context.Context, in *GetLeavesByRangeRequest, opts ...grpc.CallOption) (*GetLeavesByRangeResponse, error)
	// Returns a batch of leaves by their `merkle_leaf_hash` values.
	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) AddSequencedLeaf(ctx context.Context, in *AddSequencedLeafRequest, opts ...grpc.CallOption) (*AddSequencedLeafResponse, error) {
	out := new(AddSequencedLeafResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/AddSequencedLeaf", 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) InitLog(ctx context.Context, in *InitLogRequest, opts ...grpc.CallOption) (*InitLogResponse, error) {
	out := new(InitLogResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/InitLog", 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) AddSequencedLeaves(ctx context.Context, in *AddSequencedLeavesRequest, opts ...grpc.CallOption) (*AddSequencedLeavesResponse, error) {
	out := new(AddSequencedLeavesResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/AddSequencedLeaves", 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) GetLeavesByRange(ctx context.Context, in *GetLeavesByRangeRequest, opts ...grpc.CallOption) (*GetLeavesByRangeResponse, error) {
	out := new(GetLeavesByRangeResponse)
	err := grpc.Invoke(ctx, "/trillian.TrillianLog/GetLeavesByRange", 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 {
	// Adds a single leaf to the queue.
	QueueLeaf(context.Context, *QueueLeafRequest) (*QueueLeafResponse, error)
	// Adds a single leaf with an assigned sequence number.
	// Warning: This RPC is under development, don't use it.
	AddSequencedLeaf(context.Context, *AddSequencedLeafRequest) (*AddSequencedLeafResponse, error)
	// Returns inclusion proof for a leaf with a given index in a given tree.
	GetInclusionProof(context.Context, *GetInclusionProofRequest) (*GetInclusionProofResponse, error)
	// Returns inclusion proof for a leaf with a given identity hash in a given
	// tree.
	GetInclusionProofByHash(context.Context, *GetInclusionProofByHashRequest) (*GetInclusionProofByHashResponse, error)
	// Returns consistency proof between two versions of a given tree.
	GetConsistencyProof(context.Context, *GetConsistencyProofRequest) (*GetConsistencyProofResponse, error)
	// Returns the latest signed log root for a given tree. Corresponds to the
	// ReadOnlyLogTreeTX.LatestSignedLogRoot storage interface.
	GetLatestSignedLogRoot(context.Context, *GetLatestSignedLogRootRequest) (*GetLatestSignedLogRootResponse, error)
	// Returns the total number of leaves that have been integrated into the
	// given tree. Corresponds to the ReadOnlyLogTreeTX.GetSequencedLeafCount
	// storage interface.
	// DO NOT USE - FOR DEBUGGING/TEST ONLY
	GetSequencedLeafCount(context.Context, *GetSequencedLeafCountRequest) (*GetSequencedLeafCountResponse, error)
	// Returns log entry and the corresponding inclusion proof for a given leaf
	// index in a given tree. If the requested tree is unavailable but the leaf is in scope
	// for the current tree, return a proof in that tree instead.
	GetEntryAndProof(context.Context, *GetEntryAndProofRequest) (*GetEntryAndProofResponse, error)
	InitLog(context.Context, *InitLogRequest) (*InitLogResponse, error)
	// Adds a batch of leaves to the queue.
	QueueLeaves(context.Context, *QueueLeavesRequest) (*QueueLeavesResponse, error)
	// Stores leaves from the provided batch and associates them with the log
	// positions according to the `LeafIndex` field. The indices must be
	// contiguous.
	//
	// Warning: This RPC is under development, don't use it.
	AddSequencedLeaves(context.Context, *AddSequencedLeavesRequest) (*AddSequencedLeavesResponse, error)
	// Returns a batch of leaves located in the provided positions.
	GetLeavesByIndex(context.Context, *GetLeavesByIndexRequest) (*GetLeavesByIndexResponse, error)
	// Returns a batch of leaves in a sequential range.
	GetLeavesByRange(context.Context, *GetLeavesByRangeRequest) (*GetLeavesByRangeResponse, error)
	// Returns a batch of leaves by their `merkle_leaf_hash` values.
	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_AddSequencedLeaf_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddSequencedLeafRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).AddSequencedLeaf(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/AddSequencedLeaf",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).AddSequencedLeaf(ctx, req.(*AddSequencedLeafRequest))
	}
	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_InitLog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InitLogRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).InitLog(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/InitLog",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).InitLog(ctx, req.(*InitLogRequest))
	}
	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_AddSequencedLeaves_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddSequencedLeavesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).AddSequencedLeaves(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/AddSequencedLeaves",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).AddSequencedLeaves(ctx, req.(*AddSequencedLeavesRequest))
	}
	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_GetLeavesByRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLeavesByRangeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrillianLogServer).GetLeavesByRange(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/trillian.TrillianLog/GetLeavesByRange",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrillianLogServer).GetLeavesByRange(ctx, req.(*GetLeavesByRangeRequest))
	}
	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: "AddSequencedLeaf",
			Handler:    _TrillianLog_AddSequencedLeaf_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: "InitLog",
			Handler:    _TrillianLog_InitLog_Handler,
		},
		{
			MethodName: "QueueLeaves",
			Handler:    _TrillianLog_QueueLeaves_Handler,
		},
		{
			MethodName: "AddSequencedLeaves",
			Handler:    _TrillianLog_AddSequencedLeaves_Handler,
		},
		{
			MethodName: "GetLeavesByIndex",
			Handler:    _TrillianLog_GetLeavesByIndex_Handler,
		},
		{
			MethodName: "GetLeavesByRange",
			Handler:    _TrillianLog_GetLeavesByRange_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{
	// 1441 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x58, 0x5d, 0x6f, 0x1b, 0x45,
	0x17, 0xee, 0xc6, 0x89, 0x93, 0x9c, 0x34, 0x71, 0x32, 0x79, 0xdb, 0x38, 0x9b, 0xe6, 0x6d, 0xba,
	0x69, 0x1a, 0x37, 0x14, 0x2f, 0x29, 0x2a, 0xa0, 0xa8, 0x02, 0x35, 0x2d, 0x0a, 0xa1, 0x86, 0x06,
	0xa7, 0x2a, 0x08, 0x84, 0x56, 0x63, 0xef, 0x64, 0xb3, 0x62, 0xb3, 0xe3, 0xee, 0x8e, 0xab, 0xba,
	0x55, 0x6f, 0x40, 0x45, 0xe2, 0x82, 0x2b, 0xb8, 0xe0, 0x06, 0xc1, 0x1d, 0xe2, 0xdf, 0x20, 0xf1,
	0x17, 0xb8, 0xe0, 0x67, 0xa0, 0x9d, 0x99, 0xf5, 0x7e, 0x78, 0x77, 0x1d, 0x43, 0xdb, 0x3b, 0xef,
	0x99, 0x67, 0xce, 0x79, 0xce, 0x99, 0x39, 0x1f, 0x63, 0x38, 0xcf, 0x3c, 0xdb, 0x71, 0x6c, 0xec,
	0x1a, 0x0e, 0xb5, 0x0c, 0xdc, 0xb1, 0xeb, 0x1d, 0x8f, 0x32, 0x8a, 0xa6, 0x42, 0xb9, 0x7a, 0xc1,
	0xa2, 0xd4, 0x72, 0x88, 0x8e, 0x3b, 0xb6, 0x8e, 0x5d, 0x97, 0x32, 0xcc, 0x6c, 0xea, 0xfa, 0x02,
	0xa7, 0x5e, 0x94, 0xab, 0xfc, 0xab, 0xd5, 0x3d, 0xd2, 0x99, 0x7d, 0x42, 0x7c, 0x86, 0x4f, 0x3a,
	0x12, 0xb0, 0x24, 0x01, 0x5e, 0xa7, 0xad, 0xfb, 0x0c, 0xb3, 0x6e, 0xb8, 0x73, 0x2e, 0xb4, 0x20,
	0xbe, 0xb5, 0x03, 0x98, 0xff, 0xa4, 0x4b, 0xba, 0xa4, 0x41, 0xf0, 0x51, 0x93, 0x3c, 0xec, 0x12,
	0x9f, 0xa1, 0x73, 0x50, 0x0e, 0x68, 0xd9, 0x66, 0x55, 0x59, 0x53, 0x6a, 0xa5, 0xe6, 0x84, 0x43,
	0xad, 0x7d, 0x13, 0x6d, 0xc0, 0xb8, 0x43, 0xf0, 0x51, 0x75, 0x6c, 0x4d, 0xa9, 0xcd, 0x5c, 0x5f,
	0xa8, 0xf7, 0x35, 0x35, 0xa8, 0xc5, 0xb7, 0xf3, 0x65, 0xed, 0x23, 0x58, 0x88, 0x69, 0xf4, 0x3b,
	0xd4, 0xf5, 0x09, 0x7a, 0x07, 0x66, 0x1e, 0x06, 0x42, 0xd3, 0x88, 0xa9, 0x58, 0x8a, 0x54, 0xf0,
	0x1d, 0x66, 0xa8, 0x08, 0x04, 0x36, 0xf8, 0xad, 0x7d, 0x0a, 0x4b, 0xb7, 0x4c, 0xf3, 0x30, 0xa0,
	0xe6, 0xb6, 0x85, 0xec, 0xc5, 0xf0, 0xbc, 0x0b, 0xd5, 0x41, 0xc5, 0x92, 0xae, 0x0e, 0x65, 0x8f,
	0xf8, 0x5d, 0x87, 0x0d, 0x63, 0x2a, 0x61, 0xda, 0x09, 0x54, 0xf7, 0x08, 0xdb, 0x77, 0xdb, 0x4e,
	0xd7, 0xb7, 0xa9, 0x7b, 0xe0, 0x51, 0x3a, 0x8c, 0xe6, 0x2a, 0x40, 0xc0, 0xc3, 0xb0, 0x5d, 0x93,
	0x3c, 0xe6, 0x76, 0x4a, 0xcd, 0xe9, 0x40, 0xb2, 0x1f, 0x08, 0xd0, 0x0a, 0x4c, 0x33, 0x8f, 0x10,
	0xc3, 0xb7, 0x9f, 0x90, 0x6a, 0x89, 0xaf, 0x4e, 0x05, 0x82, 0x43, 0xfb, 0x09, 0xd1, 0xbe, 0x51,
	0x60, 0x39, 0xc3, 0x9e, 0x64, 0xbf, 0x01, 0x13, 0x9d, 0x40, 0x20, 0xc9, 0x57, 0x22, 0xf2, 0x02,
	0x27, 0x56, 0xd1, 0x7b, 0x50, 0xf1, 0x6d, 0xcb, 0x0d, 0xce, 0x84, 0x5a, 0x86, 0x47, 0x29, 0xe3,
	0x76, 0x12, 0xde, 0x1e, 0x72, 0x40, 0x83, 0x5a, 0x4d, 0x4a, 0x59, 0x73, 0xd6, 0x8f, 0x7f, 0x6a,
	0x3f, 0x2b, 0xf0, 0xff, 0x01, 0x16, 0xbb, 0xbd, 0x0f, 0xb0, 0x7f, 0x3c, 0xc4, 0xf7, 0x15, 0xe0,
	0x9e, 0x1a, 0xc7, 0xd8, 0x3f, 0xe6, 0x2c, 0xcf, 0x36, 0xa7, 0x02, 0x41, 0xb0, 0xb5, 0xd0, 0x73,
	0xb4, 0x05, 0x0b, 0xd4, 0x33, 0x89, 0x67, 0xb4, 0x7a, 0x86, 0x2f, 0xcf, 0xae, 0x3a, 0xbe, 0xa6,
	0xd4, 0xa6, 0x9a, 0x15, 0xbe, 0xb0, 0xdb, 0x0b, 0x8f, 0x54, 0xfb, 0x4e, 0x81, 0x8b, 0xb9, 0xfc,
	0x06, 0x63, 0x55, 0x7a, 0x99, 0xb1, 0x7a, 0xae, 0x80, 0xba, 0x47, 0xd8, 0x6d, 0xea, 0xfa, 0xb6,
	0xcf, 0x88, 0xdb, 0xee, 0x9d, 0xe6, 0x8e, 0x5c, 0x81, 0xca, 0x91, 0xed, 0xf9, 0xcc, 0x88, 0x02,
	0x22, 0x2e, 0xca, 0x2c, 0x17, 0xdf, 0x0f, 0xa3, 0x52, 0x83, 0x79, 0x9f, 0xb4, 0xa9, 0x6b, 0x1a,
	0xe9, 0xc8, 0xcd, 0x09, 0x79, 0x88, 0x0c, 0x78, 0xac, 0x64, 0xf2, 0x78, 0xc5, 0x77, 0xe7, 0x2d,
	0x58, 0xdd, 0x23, 0xac, 0x81, 0x19, 0xf1, 0x59, 0x12, 0x58, 0x18, 0x11, 0x0d, 0xf3, 0x2b, 0x97,
	0xb9, 0x4f, 0x7a, 0x90, 0x41, 0x6d, 0x6c, 0x24, 0x6a, 0x37, 0xe0, 0xc2, 0x1e, 0x61, 0x89, 0xc2,
	0x70, 0x9b, 0x76, 0xdd, 0x61, 0xcc, 0xde, 0xe5, 0x1e, 0x65, 0x6d, 0x93, 0xc4, 0xc2, 0x84, 0x6f,
	0x07, 0xd2, 0x78, 0xc2, 0x73, 0x98, 0xe6, 0xc0, 0xd2, 0x1e, 0x61, 0xef, 0xbb, 0xcc, 0xeb, 0xdd,
	0x72, 0xcd, 0x97, 0x5d, 0x41, 0x7e, 0x57, 0x78, 0xc5, 0x4a, 0x99, 0x1b, 0xed, 0x12, 0x84, 0x85,
	0xb6, 0x54, 0x58, 0x68, 0xb3, 0x0e, 0x64, 0x7c, 0xa4, 0x03, 0xd9, 0x84, 0xb9, 0x7d, 0xd7, 0x66,
	0xc1, 0x67, 0xf1, 0x11, 0xdc, 0x81, 0x4a, 0x1f, 0x28, 0x5d, 0xd9, 0x86, 0xc9, 0xb6, 0x47, 0x30,
	0x23, 0x02, 0x5a, 0x60, 0x34, 0xc4, 0x69, 0x0f, 0x00, 0x85, 0x0d, 0xec, 0x11, 0xf1, 0x87, 0x9c,
	0xc1, 0x55, 0x28, 0x3b, 0x1c, 0x27, 0x0b, 0x48, 0x46, 0x14, 0x24, 0x40, 0x3b, 0x84, 0xc5, 0x84,
	0x5e, 0xc9, 0xf0, 0x26, 0xcc, 0x46, 0xad, 0x31, 0x52, 0x94, 0xdb, 0x72, 0xce, 0xf6, 0x9b, 0x63,
	0xa0, 0xf4, 0x4b, 0x58, 0x4e, 0x75, 0xb1, 0x17, 0xca, 0xf9, 0x1e, 0xa8, 0x59, 0xea, 0xa3, 0xe0,
	0x8a, 0xfe, 0x37, 0x94, 0x74, 0x88, 0xd3, 0xee, 0xf1, 0x5b, 0x2e, 0xf4, 0xec, 0xf6, 0xf8, 0x45,
	0x1d, 0xf1, 0x96, 0x97, 0x12, 0xb7, 0x5c, 0xfb, 0x56, 0x5c, 0xe4, 0x94, 0x46, 0x49, 0xf0, 0xf4,
	0x9e, 0xfe, 0xf7, 0x8a, 0x66, 0x25, 0x3c, 0x6b, 0x62, 0xd7, 0x22, 0x43, 0x3c, 0xbb, 0x08, 0x33,
	0x3e, 0xc3, 0x1e, 0x4b, 0x24, 0x30, 0x70, 0x91, 0xc8, 0xe0, 0xff, 0xc1, 0x84, 0x28, 0x16, 0x22,
	0x7b, 0xc5, 0x47, 0xda, 0x63, 0x69, 0x69, 0xc0, 0x63, 0xe5, 0x5f, 0x78, 0x3c, 0x5a, 0xa1, 0x7c,
	0x0c, 0xe7, 0x63, 0x3c, 0x46, 0x6f, 0xfb, 0xa5, 0x44, 0xdb, 0xcf, 0xec, 0xec, 0xa5, 0xec, 0xce,
	0xfe, 0x5c, 0x49, 0x04, 0x3b, 0xd1, 0xd1, 0x5f, 0xe5, 0x99, 0xb7, 0x60, 0x36, 0x71, 0xcf, 0xfb,
	0x25, 0x51, 0x29, 0x2e, 0x89, 0x5b, 0x50, 0x16, 0x53, 0xb9, 0x8c, 0x38, 0xaa, 0x8b, 0x79, 0xbd,
	0xee, 0x75, 0xda, 0xf5, 0x43, 0xbe, 0xd2, 0x94, 0x08, 0xed, 0x8f, 0x31, 0x98, 0x0c, 0xd5, 0xd7,
	0x60, 0xfe, 0x84, 0x78, 0x5f, 0x39, 0xc4, 0x88, 0xe2, 0xa8, 0xf0, 0xf1, 0x69, 0x4e, 0xc8, 0x1b,
	0x61, 0x34, 0xc3, 0xac, 0x79, 0x84, 0x9d, 0x2e, 0x91, 0x23, 0x16, 0x0f, 0xfe, 0x83, 0x40, 0x10,
	0x2c, 0x93, 0xc7, 0xcc, 0xc3, 0x86, 0x89, 0x19, 0xe6, 0x4e, 0x9f, 0x6d, 0x4e, 0x73, 0xc9, 0x1d,
	0xcc, 0x70, 0x2a, 0xe7, 0xc6, 0xd3, 0x9d, 0xe5, 0x1a, 0x20, 0xb1, 0x6c, 0x12, 0x97, 0xd9, 0xac,
	0x27, 0x88, 0x4c, 0x70, 0x2d, 0xf3, 0x1c, 0x26, 0x17, 0x38, 0x95, 0xdb, 0x50, 0xe1, 0x25, 0xcb,
	0xe8, 0x3f, 0x52, 0xaa, 0x65, 0xee, 0xb5, 0x1a, 0x7a, 0x1d, 0x3e, 0x63, 0xea, 0xf7, 0x43, 0x44,
	0x73, 0x8e, 0x6f, 0xe9, 0x7f, 0xa3, 0xbb, 0xb0, 0x68, 0xbb, 0x8c, 0x58, 0x1e, 0x66, 0x71, 0x45,
	0x93, 0x43, 0x15, 0xa1, 0xfe, 0xb6, 0xbe, 0x4c, 0xbb, 0x03, 0x13, 0xbc, 0x91, 0xa5, 0xfc, 0x54,
	0xd2, 0x7e, 0x9e, 0x87, 0x72, 0xe0, 0x19, 0xf1, 0xab, 0x25, 0x7e, 0x59, 0xe5, 0xd7, 0x87, 0xe3,
	0x53, 0x63, 0xf3, 0xa5, 0xeb, 0x7f, 0xcf, 0xc2, 0xcc, 0x7d, 0x79, 0xbe, 0x0d, 0x6a, 0x21, 0x17,
	0xa6, 0xfb, 0x0f, 0x1f, 0xa4, 0xa6, 0x2a, 0x61, 0xec, 0xdd, 0xa2, 0xae, 0x64, 0xae, 0x89, 0xeb,
	0xab, 0xd5, 0xbe, 0xfe, 0xf3, 0xaf, 0x1f, 0xc6, 0x34, 0x6d, 0x55, 0x7f, 0xb4, 0xdd, 0x22, 0x0c,
	0x6f, 0xeb, 0x0e, 0xb5, 0x7c, 0xfd, 0xa9, 0xc8, 0xa7, 0x67, 0xba, 0xb8, 0xba, 0x3b, 0xca, 0x16,
	0xfa, 0x5e, 0x81, 0xf9, 0xf4, 0x0b, 0x06, 0x5d, 0x8a, 0x74, 0xe7, 0x3c, 0x9b, 0x54, 0xad, 0x08,
	0x22, 0x59, 0x5c, 0xe7, 0x2c, 0xae, 0x69, 0x9b, 0xc5, 0x2c, 0xc2, 0x3c, 0x35, 0x03, 0x3e, 0xbf,
	0x2a, 0xb0, 0x30, 0x30, 0x6e, 0xa3, 0x98, 0xb5, 0xbc, 0x17, 0x92, 0xba, 0x5e, 0x88, 0x91, 0x94,
	0x76, 0x39, 0xa5, 0x9b, 0x68, 0xa7, 0x90, 0x92, 0xfe, 0x34, 0x3a, 0xd0, 0x67, 0x3b, 0x76, 0xa8,
	0xca, 0x10, 0x13, 0xcb, 0x6f, 0xa2, 0x6e, 0x64, 0xbd, 0x08, 0x50, 0xad, 0x80, 0x44, 0xa2, 0xba,
	0xa9, 0x57, 0x4f, 0x81, 0x94, 0xa4, 0xdf, 0xe6, 0xa4, 0xb7, 0x91, 0x5e, 0x1c, 0xc7, 0x88, 0x67,
	0x4b, 0x24, 0x13, 0xfa, 0x51, 0x81, 0xc5, 0x8c, 0x39, 0x1d, 0x5d, 0x4e, 0xd8, 0xce, 0x79, 0x4e,
	0xa8, 0x1b, 0x43, 0x50, 0x92, 0xdd, 0x1b, 0x9c, 0xdd, 0x16, 0xaa, 0x65, 0xb3, 0xdb, 0x69, 0x47,
	0x1b, 0x65, 0x00, 0x7f, 0x52, 0x44, 0xcd, 0x1f, 0x9c, 0xbf, 0xd1, 0x66, 0xc2, 0x66, 0xfe, 0x64,
	0xaf, 0xd6, 0x86, 0x03, 0x25, 0xbf, 0xd7, 0x38, 0xbf, 0x0d, 0xb4, 0x9e, 0x13, 0xbd, 0xa0, 0x62,
	0xfb, 0x3b, 0x0e, 0xd7, 0x80, 0x7e, 0x51, 0xe0, 0x5c, 0xe6, 0x00, 0x8e, 0xae, 0x24, 0x0c, 0xe6,
	0x0e, 0xf6, 0xea, 0xe6, 0x50, 0x9c, 0xe4, 0x75, 0x83, 0xf3, 0xd2, 0xd1, 0xeb, 0xa7, 0xcc, 0x0e,
	0x31, 0xf2, 0xf3, 0x84, 0x4d, 0xcf, 0xdc, 0xf1, 0x84, 0xcd, 0x19, 0xff, 0x55, 0xad, 0x08, 0x92,
	0x4c, 0x58, 0xb4, 0x75, 0xfa, 0xec, 0x40, 0x6d, 0x98, 0x94, 0xe3, 0x32, 0xaa, 0x46, 0x26, 0x92,
	0xa3, 0xb6, 0xba, 0x9c, 0xb1, 0x22, 0x6d, 0xae, 0x73, 0x9b, 0xab, 0xda, 0x4a, 0xce, 0xf5, 0xb1,
	0x5d, 0x9b, 0xa1, 0x06, 0xcc, 0xc4, 0xa6, 0x5e, 0x74, 0x61, 0xb0, 0xf6, 0x45, 0x03, 0xab, 0xba,
	0x9a, 0xb3, 0x2a, 0x0d, 0x9e, 0x41, 0x18, 0xd0, 0xe0, 0x3c, 0x8a, 0xd6, 0x73, 0x2b, 0x5a, 0x4c,
	0xf7, 0xe5, 0x62, 0x50, 0xdf, 0xc4, 0x17, 0xfc, 0x90, 0x12, 0xf3, 0x64, 0xea, 0x90, 0xb2, 0xa6,
	0xd7, 0xd4, 0x21, 0x65, 0x8e, 0xa3, 0x03, 0xca, 0xf9, 0xe8, 0x96, 0xa3, 0x3c, 0x3e, 0x40, 0xe6,
	0x28, 0x4f, 0x4c, 0x7e, 0xda, 0x19, 0xf4, 0x19, 0x54, 0x52, 0x43, 0x11, 0x5a, 0xcb, 0xdc, 0x18,
	0x2f, 0x66, 0x97, 0x0a, 0x10, 0xa1, 0xe6, 0xdd, 0x8f, 0x61, 0xb9, 0x4d, 0x4f, 0xc2, 0x2e, 0x9b,
	0xfc, 0x0b, 0x71, 0x77, 0x31, 0xd6, 0x04, 0x6f, 0x75, 0xec, 0x83, 0x40, 0x78, 0xa0, 0x7c, 0xae,
	0x5a, 0x36, 0x3b, 0xee, 0xb6, 0xea, 0x6d, 0x7a, 0xa2, 0xcb, 0x7f, 0x23, 0xc3, 0x8d, 0xad, 0x32,
	0xdf, 0xf9, 0xe6, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa0, 0x2c, 0x48, 0x03, 0x08, 0x15, 0x00,
	0x00,
}
