tendermint/types/types.pb.go

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

/*
Package types is a generated protocol buffer package.

It is generated from these files:
	types/types.proto

It has these top-level messages:
	Request
	RequestEcho
	RequestFlush
	RequestInfo
	RequestSetOption
	RequestDeliverTx
	RequestCheckTx
	RequestQuery
	RequestCommit
	RequestInitChain
	RequestBeginBlock
	RequestEndBlock
	Response
	ResponseException
	ResponseEcho
	ResponseFlush
	ResponseInfo
	ResponseSetOption
	ResponseDeliverTx
	ResponseCheckTx
	ResponseQuery
	ResponseCommit
	ResponseInitChain
	ResponseBeginBlock
	ResponseEndBlock
	Header
	BlockID
	PartSetHeader
	Validator
	KVPair
*/
package types

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

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

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

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

type KVPair_Type int32

const (
	KVPair_STRING KVPair_Type = 0
	KVPair_INT    KVPair_Type = 1
)

var KVPair_Type_name = map[int32]string{
	0: "STRING",
	1: "INT",
}
var KVPair_Type_value = map[string]int32{
	"STRING": 0,
	"INT":    1,
}

func (x KVPair_Type) String() string {
	return proto.EnumName(KVPair_Type_name, int32(x))
}
func (KVPair_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{29, 0} }

type Request struct {
	// Types that are valid to be assigned to Value:
	//	*Request_Echo
	//	*Request_Flush
	//	*Request_Info
	//	*Request_SetOption
	//	*Request_DeliverTx
	//	*Request_CheckTx
	//	*Request_Commit
	//	*Request_Query
	//	*Request_InitChain
	//	*Request_BeginBlock
	//	*Request_EndBlock
	Value isRequest_Value `protobuf_oneof:"value"`
}

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

type isRequest_Value interface {
	isRequest_Value()
}

type Request_Echo struct {
	Echo *RequestEcho `protobuf:"bytes,1,opt,name=echo,oneof"`
}
type Request_Flush struct {
	Flush *RequestFlush `protobuf:"bytes,2,opt,name=flush,oneof"`
}
type Request_Info struct {
	Info *RequestInfo `protobuf:"bytes,3,opt,name=info,oneof"`
}
type Request_SetOption struct {
	SetOption *RequestSetOption `protobuf:"bytes,4,opt,name=set_option,json=setOption,oneof"`
}
type Request_DeliverTx struct {
	DeliverTx *RequestDeliverTx `protobuf:"bytes,5,opt,name=deliver_tx,json=deliverTx,oneof"`
}
type Request_CheckTx struct {
	CheckTx *RequestCheckTx `protobuf:"bytes,6,opt,name=check_tx,json=checkTx,oneof"`
}
type Request_Commit struct {
	Commit *RequestCommit `protobuf:"bytes,7,opt,name=commit,oneof"`
}
type Request_Query struct {
	Query *RequestQuery `protobuf:"bytes,8,opt,name=query,oneof"`
}
type Request_InitChain struct {
	InitChain *RequestInitChain `protobuf:"bytes,9,opt,name=init_chain,json=initChain,oneof"`
}
type Request_BeginBlock struct {
	BeginBlock *RequestBeginBlock `protobuf:"bytes,10,opt,name=begin_block,json=beginBlock,oneof"`
}
type Request_EndBlock struct {
	EndBlock *RequestEndBlock `protobuf:"bytes,11,opt,name=end_block,json=endBlock,oneof"`
}

func (*Request_Echo) isRequest_Value()       {}
func (*Request_Flush) isRequest_Value()      {}
func (*Request_Info) isRequest_Value()       {}
func (*Request_SetOption) isRequest_Value()  {}
func (*Request_DeliverTx) isRequest_Value()  {}
func (*Request_CheckTx) isRequest_Value()    {}
func (*Request_Commit) isRequest_Value()     {}
func (*Request_Query) isRequest_Value()      {}
func (*Request_InitChain) isRequest_Value()  {}
func (*Request_BeginBlock) isRequest_Value() {}
func (*Request_EndBlock) isRequest_Value()   {}

func (m *Request) GetValue() isRequest_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Request) GetEcho() *RequestEcho {
	if x, ok := m.GetValue().(*Request_Echo); ok {
		return x.Echo
	}
	return nil
}

func (m *Request) GetFlush() *RequestFlush {
	if x, ok := m.GetValue().(*Request_Flush); ok {
		return x.Flush
	}
	return nil
}

func (m *Request) GetInfo() *RequestInfo {
	if x, ok := m.GetValue().(*Request_Info); ok {
		return x.Info
	}
	return nil
}

func (m *Request) GetSetOption() *RequestSetOption {
	if x, ok := m.GetValue().(*Request_SetOption); ok {
		return x.SetOption
	}
	return nil
}

func (m *Request) GetDeliverTx() *RequestDeliverTx {
	if x, ok := m.GetValue().(*Request_DeliverTx); ok {
		return x.DeliverTx
	}
	return nil
}

func (m *Request) GetCheckTx() *RequestCheckTx {
	if x, ok := m.GetValue().(*Request_CheckTx); ok {
		return x.CheckTx
	}
	return nil
}

func (m *Request) GetCommit() *RequestCommit {
	if x, ok := m.GetValue().(*Request_Commit); ok {
		return x.Commit
	}
	return nil
}

func (m *Request) GetQuery() *RequestQuery {
	if x, ok := m.GetValue().(*Request_Query); ok {
		return x.Query
	}
	return nil
}

func (m *Request) GetInitChain() *RequestInitChain {
	if x, ok := m.GetValue().(*Request_InitChain); ok {
		return x.InitChain
	}
	return nil
}

func (m *Request) GetBeginBlock() *RequestBeginBlock {
	if x, ok := m.GetValue().(*Request_BeginBlock); ok {
		return x.BeginBlock
	}
	return nil
}

func (m *Request) GetEndBlock() *RequestEndBlock {
	if x, ok := m.GetValue().(*Request_EndBlock); ok {
		return x.EndBlock
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Request) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Request_OneofMarshaler, _Request_OneofUnmarshaler, _Request_OneofSizer, []interface{}{
		(*Request_Echo)(nil),
		(*Request_Flush)(nil),
		(*Request_Info)(nil),
		(*Request_SetOption)(nil),
		(*Request_DeliverTx)(nil),
		(*Request_CheckTx)(nil),
		(*Request_Commit)(nil),
		(*Request_Query)(nil),
		(*Request_InitChain)(nil),
		(*Request_BeginBlock)(nil),
		(*Request_EndBlock)(nil),
	}
}

func _Request_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Request)
	// value
	switch x := m.Value.(type) {
	case *Request_Echo:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Echo); err != nil {
			return err
		}
	case *Request_Flush:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Flush); err != nil {
			return err
		}
	case *Request_Info:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Info); err != nil {
			return err
		}
	case *Request_SetOption:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.SetOption); err != nil {
			return err
		}
	case *Request_DeliverTx:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DeliverTx); err != nil {
			return err
		}
	case *Request_CheckTx:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.CheckTx); err != nil {
			return err
		}
	case *Request_Commit:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Commit); err != nil {
			return err
		}
	case *Request_Query:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Query); err != nil {
			return err
		}
	case *Request_InitChain:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.InitChain); err != nil {
			return err
		}
	case *Request_BeginBlock:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.BeginBlock); err != nil {
			return err
		}
	case *Request_EndBlock:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.EndBlock); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Request.Value has unexpected type %T", x)
	}
	return nil
}

func _Request_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Request)
	switch tag {
	case 1: // value.echo
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestEcho)
		err := b.DecodeMessage(msg)
		m.Value = &Request_Echo{msg}
		return true, err
	case 2: // value.flush
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestFlush)
		err := b.DecodeMessage(msg)
		m.Value = &Request_Flush{msg}
		return true, err
	case 3: // value.info
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestInfo)
		err := b.DecodeMessage(msg)
		m.Value = &Request_Info{msg}
		return true, err
	case 4: // value.set_option
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestSetOption)
		err := b.DecodeMessage(msg)
		m.Value = &Request_SetOption{msg}
		return true, err
	case 5: // value.deliver_tx
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestDeliverTx)
		err := b.DecodeMessage(msg)
		m.Value = &Request_DeliverTx{msg}
		return true, err
	case 6: // value.check_tx
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestCheckTx)
		err := b.DecodeMessage(msg)
		m.Value = &Request_CheckTx{msg}
		return true, err
	case 7: // value.commit
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestCommit)
		err := b.DecodeMessage(msg)
		m.Value = &Request_Commit{msg}
		return true, err
	case 8: // value.query
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestQuery)
		err := b.DecodeMessage(msg)
		m.Value = &Request_Query{msg}
		return true, err
	case 9: // value.init_chain
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestInitChain)
		err := b.DecodeMessage(msg)
		m.Value = &Request_InitChain{msg}
		return true, err
	case 10: // value.begin_block
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestBeginBlock)
		err := b.DecodeMessage(msg)
		m.Value = &Request_BeginBlock{msg}
		return true, err
	case 11: // value.end_block
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestEndBlock)
		err := b.DecodeMessage(msg)
		m.Value = &Request_EndBlock{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Request_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Request)
	// value
	switch x := m.Value.(type) {
	case *Request_Echo:
		s := proto.Size(x.Echo)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Request_Flush:
		s := proto.Size(x.Flush)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Request_Info:
		s := proto.Size(x.Info)
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Request_SetOption:
		s := proto.Size(x.SetOption)
		n += proto.SizeVarint(4<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Request_DeliverTx:
		s := proto.Size(x.DeliverTx)
		n += proto.SizeVarint(5<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Request_CheckTx:
		s := proto.Size(x.CheckTx)
		n += proto.SizeVarint(6<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Request_Commit:
		s := proto.Size(x.Commit)
		n += proto.SizeVarint(7<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Request_Query:
		s := proto.Size(x.Query)
		n += proto.SizeVarint(8<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Request_InitChain:
		s := proto.Size(x.InitChain)
		n += proto.SizeVarint(9<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Request_BeginBlock:
		s := proto.Size(x.BeginBlock)
		n += proto.SizeVarint(10<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Request_EndBlock:
		s := proto.Size(x.EndBlock)
		n += proto.SizeVarint(11<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type RequestEcho struct {
	Message string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
}

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

func (m *RequestEcho) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type RequestFlush struct {
}

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

type RequestInfo struct {
	Version string `protobuf:"bytes,1,opt,name=version" json:"version,omitempty"`
}

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

func (m *RequestInfo) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

type RequestSetOption struct {
	Key   string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	Value string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
}

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

func (m *RequestSetOption) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *RequestSetOption) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type RequestDeliverTx struct {
	Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
}

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

func (m *RequestDeliverTx) GetTx() []byte {
	if m != nil {
		return m.Tx
	}
	return nil
}

type RequestCheckTx struct {
	Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
}

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

func (m *RequestCheckTx) GetTx() []byte {
	if m != nil {
		return m.Tx
	}
	return nil
}

type RequestQuery struct {
	Data   []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	Path   string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
	Height uint64 `protobuf:"varint,3,opt,name=height" json:"height,omitempty"`
	Prove  bool   `protobuf:"varint,4,opt,name=prove" json:"prove,omitempty"`
}

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

func (m *RequestQuery) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *RequestQuery) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RequestQuery) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *RequestQuery) GetProve() bool {
	if m != nil {
		return m.Prove
	}
	return false
}

type RequestCommit struct {
}

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

type RequestInitChain struct {
	Validators []*Validator `protobuf:"bytes,1,rep,name=validators" json:"validators,omitempty"`
}

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

func (m *RequestInitChain) GetValidators() []*Validator {
	if m != nil {
		return m.Validators
	}
	return nil
}

type RequestBeginBlock struct {
	Hash   []byte  `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Header *Header `protobuf:"bytes,2,opt,name=header" json:"header,omitempty"`
}

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

func (m *RequestBeginBlock) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *RequestBeginBlock) GetHeader() *Header {
	if m != nil {
		return m.Header
	}
	return nil
}

type RequestEndBlock struct {
	Height uint64 `protobuf:"varint,1,opt,name=height" json:"height,omitempty"`
}

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

func (m *RequestEndBlock) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

type Response struct {
	// Types that are valid to be assigned to Value:
	//	*Response_Exception
	//	*Response_Echo
	//	*Response_Flush
	//	*Response_Info
	//	*Response_SetOption
	//	*Response_DeliverTx
	//	*Response_CheckTx
	//	*Response_Commit
	//	*Response_Query
	//	*Response_InitChain
	//	*Response_BeginBlock
	//	*Response_EndBlock
	Value isResponse_Value `protobuf_oneof:"value"`
}

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

type isResponse_Value interface {
	isResponse_Value()
}

type Response_Exception struct {
	Exception *ResponseException `protobuf:"bytes,1,opt,name=exception,oneof"`
}
type Response_Echo struct {
	Echo *ResponseEcho `protobuf:"bytes,2,opt,name=echo,oneof"`
}
type Response_Flush struct {
	Flush *ResponseFlush `protobuf:"bytes,3,opt,name=flush,oneof"`
}
type Response_Info struct {
	Info *ResponseInfo `protobuf:"bytes,4,opt,name=info,oneof"`
}
type Response_SetOption struct {
	SetOption *ResponseSetOption `protobuf:"bytes,5,opt,name=set_option,json=setOption,oneof"`
}
type Response_DeliverTx struct {
	DeliverTx *ResponseDeliverTx `protobuf:"bytes,6,opt,name=deliver_tx,json=deliverTx,oneof"`
}
type Response_CheckTx struct {
	CheckTx *ResponseCheckTx `protobuf:"bytes,7,opt,name=check_tx,json=checkTx,oneof"`
}
type Response_Commit struct {
	Commit *ResponseCommit `protobuf:"bytes,8,opt,name=commit,oneof"`
}
type Response_Query struct {
	Query *ResponseQuery `protobuf:"bytes,9,opt,name=query,oneof"`
}
type Response_InitChain struct {
	InitChain *ResponseInitChain `protobuf:"bytes,10,opt,name=init_chain,json=initChain,oneof"`
}
type Response_BeginBlock struct {
	BeginBlock *ResponseBeginBlock `protobuf:"bytes,11,opt,name=begin_block,json=beginBlock,oneof"`
}
type Response_EndBlock struct {
	EndBlock *ResponseEndBlock `protobuf:"bytes,12,opt,name=end_block,json=endBlock,oneof"`
}

func (*Response_Exception) isResponse_Value()  {}
func (*Response_Echo) isResponse_Value()       {}
func (*Response_Flush) isResponse_Value()      {}
func (*Response_Info) isResponse_Value()       {}
func (*Response_SetOption) isResponse_Value()  {}
func (*Response_DeliverTx) isResponse_Value()  {}
func (*Response_CheckTx) isResponse_Value()    {}
func (*Response_Commit) isResponse_Value()     {}
func (*Response_Query) isResponse_Value()      {}
func (*Response_InitChain) isResponse_Value()  {}
func (*Response_BeginBlock) isResponse_Value() {}
func (*Response_EndBlock) isResponse_Value()   {}

func (m *Response) GetValue() isResponse_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Response) GetException() *ResponseException {
	if x, ok := m.GetValue().(*Response_Exception); ok {
		return x.Exception
	}
	return nil
}

func (m *Response) GetEcho() *ResponseEcho {
	if x, ok := m.GetValue().(*Response_Echo); ok {
		return x.Echo
	}
	return nil
}

func (m *Response) GetFlush() *ResponseFlush {
	if x, ok := m.GetValue().(*Response_Flush); ok {
		return x.Flush
	}
	return nil
}

func (m *Response) GetInfo() *ResponseInfo {
	if x, ok := m.GetValue().(*Response_Info); ok {
		return x.Info
	}
	return nil
}

func (m *Response) GetSetOption() *ResponseSetOption {
	if x, ok := m.GetValue().(*Response_SetOption); ok {
		return x.SetOption
	}
	return nil
}

func (m *Response) GetDeliverTx() *ResponseDeliverTx {
	if x, ok := m.GetValue().(*Response_DeliverTx); ok {
		return x.DeliverTx
	}
	return nil
}

func (m *Response) GetCheckTx() *ResponseCheckTx {
	if x, ok := m.GetValue().(*Response_CheckTx); ok {
		return x.CheckTx
	}
	return nil
}

func (m *Response) GetCommit() *ResponseCommit {
	if x, ok := m.GetValue().(*Response_Commit); ok {
		return x.Commit
	}
	return nil
}

func (m *Response) GetQuery() *ResponseQuery {
	if x, ok := m.GetValue().(*Response_Query); ok {
		return x.Query
	}
	return nil
}

func (m *Response) GetInitChain() *ResponseInitChain {
	if x, ok := m.GetValue().(*Response_InitChain); ok {
		return x.InitChain
	}
	return nil
}

func (m *Response) GetBeginBlock() *ResponseBeginBlock {
	if x, ok := m.GetValue().(*Response_BeginBlock); ok {
		return x.BeginBlock
	}
	return nil
}

func (m *Response) GetEndBlock() *ResponseEndBlock {
	if x, ok := m.GetValue().(*Response_EndBlock); ok {
		return x.EndBlock
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Response) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Response_OneofMarshaler, _Response_OneofUnmarshaler, _Response_OneofSizer, []interface{}{
		(*Response_Exception)(nil),
		(*Response_Echo)(nil),
		(*Response_Flush)(nil),
		(*Response_Info)(nil),
		(*Response_SetOption)(nil),
		(*Response_DeliverTx)(nil),
		(*Response_CheckTx)(nil),
		(*Response_Commit)(nil),
		(*Response_Query)(nil),
		(*Response_InitChain)(nil),
		(*Response_BeginBlock)(nil),
		(*Response_EndBlock)(nil),
	}
}

func _Response_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Response)
	// value
	switch x := m.Value.(type) {
	case *Response_Exception:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Exception); err != nil {
			return err
		}
	case *Response_Echo:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Echo); err != nil {
			return err
		}
	case *Response_Flush:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Flush); err != nil {
			return err
		}
	case *Response_Info:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Info); err != nil {
			return err
		}
	case *Response_SetOption:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.SetOption); err != nil {
			return err
		}
	case *Response_DeliverTx:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DeliverTx); err != nil {
			return err
		}
	case *Response_CheckTx:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.CheckTx); err != nil {
			return err
		}
	case *Response_Commit:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Commit); err != nil {
			return err
		}
	case *Response_Query:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Query); err != nil {
			return err
		}
	case *Response_InitChain:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.InitChain); err != nil {
			return err
		}
	case *Response_BeginBlock:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.BeginBlock); err != nil {
			return err
		}
	case *Response_EndBlock:
		b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.EndBlock); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Response.Value has unexpected type %T", x)
	}
	return nil
}

func _Response_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Response)
	switch tag {
	case 1: // value.exception
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseException)
		err := b.DecodeMessage(msg)
		m.Value = &Response_Exception{msg}
		return true, err
	case 2: // value.echo
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseEcho)
		err := b.DecodeMessage(msg)
		m.Value = &Response_Echo{msg}
		return true, err
	case 3: // value.flush
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseFlush)
		err := b.DecodeMessage(msg)
		m.Value = &Response_Flush{msg}
		return true, err
	case 4: // value.info
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseInfo)
		err := b.DecodeMessage(msg)
		m.Value = &Response_Info{msg}
		return true, err
	case 5: // value.set_option
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseSetOption)
		err := b.DecodeMessage(msg)
		m.Value = &Response_SetOption{msg}
		return true, err
	case 6: // value.deliver_tx
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseDeliverTx)
		err := b.DecodeMessage(msg)
		m.Value = &Response_DeliverTx{msg}
		return true, err
	case 7: // value.check_tx
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseCheckTx)
		err := b.DecodeMessage(msg)
		m.Value = &Response_CheckTx{msg}
		return true, err
	case 8: // value.commit
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseCommit)
		err := b.DecodeMessage(msg)
		m.Value = &Response_Commit{msg}
		return true, err
	case 9: // value.query
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseQuery)
		err := b.DecodeMessage(msg)
		m.Value = &Response_Query{msg}
		return true, err
	case 10: // value.init_chain
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseInitChain)
		err := b.DecodeMessage(msg)
		m.Value = &Response_InitChain{msg}
		return true, err
	case 11: // value.begin_block
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseBeginBlock)
		err := b.DecodeMessage(msg)
		m.Value = &Response_BeginBlock{msg}
		return true, err
	case 12: // value.end_block
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseEndBlock)
		err := b.DecodeMessage(msg)
		m.Value = &Response_EndBlock{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Response_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Response)
	// value
	switch x := m.Value.(type) {
	case *Response_Exception:
		s := proto.Size(x.Exception)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Response_Echo:
		s := proto.Size(x.Echo)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Response_Flush:
		s := proto.Size(x.Flush)
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Response_Info:
		s := proto.Size(x.Info)
		n += proto.SizeVarint(4<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Response_SetOption:
		s := proto.Size(x.SetOption)
		n += proto.SizeVarint(5<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Response_DeliverTx:
		s := proto.Size(x.DeliverTx)
		n += proto.SizeVarint(6<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Response_CheckTx:
		s := proto.Size(x.CheckTx)
		n += proto.SizeVarint(7<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Response_Commit:
		s := proto.Size(x.Commit)
		n += proto.SizeVarint(8<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Response_Query:
		s := proto.Size(x.Query)
		n += proto.SizeVarint(9<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Response_InitChain:
		s := proto.Size(x.InitChain)
		n += proto.SizeVarint(10<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Response_BeginBlock:
		s := proto.Size(x.BeginBlock)
		n += proto.SizeVarint(11<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Response_EndBlock:
		s := proto.Size(x.EndBlock)
		n += proto.SizeVarint(12<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type ResponseException struct {
	Error string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
}

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

func (m *ResponseException) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

type ResponseEcho struct {
	Message string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
}

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

func (m *ResponseEcho) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type ResponseFlush struct {
}

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

type ResponseInfo struct {
	Data             string `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
	Version          string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
	LastBlockHeight  uint64 `protobuf:"varint,3,opt,name=last_block_height,json=lastBlockHeight" json:"last_block_height,omitempty"`
	LastBlockAppHash []byte `protobuf:"bytes,4,opt,name=last_block_app_hash,json=lastBlockAppHash,proto3" json:"last_block_app_hash,omitempty"`
}

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

func (m *ResponseInfo) GetData() string {
	if m != nil {
		return m.Data
	}
	return ""
}

func (m *ResponseInfo) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *ResponseInfo) GetLastBlockHeight() uint64 {
	if m != nil {
		return m.LastBlockHeight
	}
	return 0
}

func (m *ResponseInfo) GetLastBlockAppHash() []byte {
	if m != nil {
		return m.LastBlockAppHash
	}
	return nil
}

type ResponseSetOption struct {
	Log string `protobuf:"bytes,1,opt,name=log" json:"log,omitempty"`
}

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

func (m *ResponseSetOption) GetLog() string {
	if m != nil {
		return m.Log
	}
	return ""
}

type ResponseDeliverTx struct {
	Code uint32    `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
	Data []byte    `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	Log  string    `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
	Tags []*KVPair `protobuf:"bytes,4,rep,name=tags" json:"tags,omitempty"`
}

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

func (m *ResponseDeliverTx) GetCode() uint32 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *ResponseDeliverTx) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *ResponseDeliverTx) GetLog() string {
	if m != nil {
		return m.Log
	}
	return ""
}

func (m *ResponseDeliverTx) GetTags() []*KVPair {
	if m != nil {
		return m.Tags
	}
	return nil
}

type ResponseCheckTx struct {
	Code uint32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	Log  string `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
	Gas  uint64 `protobuf:"varint,4,opt,name=gas" json:"gas,omitempty"`
	Fee  uint64 `protobuf:"varint,5,opt,name=fee" json:"fee,omitempty"`
}

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

func (m *ResponseCheckTx) GetCode() uint32 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *ResponseCheckTx) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *ResponseCheckTx) GetLog() string {
	if m != nil {
		return m.Log
	}
	return ""
}

func (m *ResponseCheckTx) GetGas() uint64 {
	if m != nil {
		return m.Gas
	}
	return 0
}

func (m *ResponseCheckTx) GetFee() uint64 {
	if m != nil {
		return m.Fee
	}
	return 0
}

type ResponseQuery struct {
	Code   uint32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
	Index  int64  `protobuf:"varint,2,opt,name=index" json:"index,omitempty"`
	Key    []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	Value  []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
	Proof  []byte `protobuf:"bytes,5,opt,name=proof,proto3" json:"proof,omitempty"`
	Height uint64 `protobuf:"varint,6,opt,name=height" json:"height,omitempty"`
	Log    string `protobuf:"bytes,7,opt,name=log" json:"log,omitempty"`
}

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

func (m *ResponseQuery) GetCode() uint32 {
	if m != nil {
		return m.Code
	}
	return 0
}

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

func (m *ResponseQuery) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *ResponseQuery) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

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

func (m *ResponseQuery) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *ResponseQuery) GetLog() string {
	if m != nil {
		return m.Log
	}
	return ""
}

type ResponseCommit struct {
	Code uint32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	Log  string `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
}

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

func (m *ResponseCommit) GetCode() uint32 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *ResponseCommit) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *ResponseCommit) GetLog() string {
	if m != nil {
		return m.Log
	}
	return ""
}

type ResponseInitChain struct {
}

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

type ResponseBeginBlock struct {
}

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

type ResponseEndBlock struct {
	Diffs []*Validator `protobuf:"bytes,1,rep,name=diffs" json:"diffs,omitempty"`
}

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

func (m *ResponseEndBlock) GetDiffs() []*Validator {
	if m != nil {
		return m.Diffs
	}
	return nil
}

type Header struct {
	ChainId        string   `protobuf:"bytes,1,opt,name=chain_id,json=chainId" json:"chain_id,omitempty"`
	Height         uint64   `protobuf:"varint,2,opt,name=height" json:"height,omitempty"`
	Time           uint64   `protobuf:"varint,3,opt,name=time" json:"time,omitempty"`
	NumTxs         uint64   `protobuf:"varint,4,opt,name=num_txs,json=numTxs" json:"num_txs,omitempty"`
	LastBlockId    *BlockID `protobuf:"bytes,5,opt,name=last_block_id,json=lastBlockId" json:"last_block_id,omitempty"`
	LastCommitHash []byte   `protobuf:"bytes,6,opt,name=last_commit_hash,json=lastCommitHash,proto3" json:"last_commit_hash,omitempty"`
	DataHash       []byte   `protobuf:"bytes,7,opt,name=data_hash,json=dataHash,proto3" json:"data_hash,omitempty"`
	ValidatorsHash []byte   `protobuf:"bytes,8,opt,name=validators_hash,json=validatorsHash,proto3" json:"validators_hash,omitempty"`
	AppHash        []byte   `protobuf:"bytes,9,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
}

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

func (m *Header) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *Header) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *Header) GetTime() uint64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *Header) GetNumTxs() uint64 {
	if m != nil {
		return m.NumTxs
	}
	return 0
}

func (m *Header) GetLastBlockId() *BlockID {
	if m != nil {
		return m.LastBlockId
	}
	return nil
}

func (m *Header) GetLastCommitHash() []byte {
	if m != nil {
		return m.LastCommitHash
	}
	return nil
}

func (m *Header) GetDataHash() []byte {
	if m != nil {
		return m.DataHash
	}
	return nil
}

func (m *Header) GetValidatorsHash() []byte {
	if m != nil {
		return m.ValidatorsHash
	}
	return nil
}

func (m *Header) GetAppHash() []byte {
	if m != nil {
		return m.AppHash
	}
	return nil
}

type BlockID struct {
	Hash  []byte         `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Parts *PartSetHeader `protobuf:"bytes,2,opt,name=parts" json:"parts,omitempty"`
}

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

func (m *BlockID) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *BlockID) GetParts() *PartSetHeader {
	if m != nil {
		return m.Parts
	}
	return nil
}

type PartSetHeader struct {
	Total uint64 `protobuf:"varint,1,opt,name=total" json:"total,omitempty"`
	Hash  []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
}

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

func (m *PartSetHeader) GetTotal() uint64 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *PartSetHeader) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

type Validator struct {
	PubKey []byte `protobuf:"bytes,1,opt,name=pubKey,proto3" json:"pubKey,omitempty"`
	Power  uint64 `protobuf:"varint,2,opt,name=power" json:"power,omitempty"`
}

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

func (m *Validator) GetPubKey() []byte {
	if m != nil {
		return m.PubKey
	}
	return nil
}

func (m *Validator) GetPower() uint64 {
	if m != nil {
		return m.Power
	}
	return 0
}

type KVPair struct {
	Key         string      `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	ValueType   KVPair_Type `protobuf:"varint,2,opt,name=value_type,json=valueType,enum=types.KVPair_Type" json:"value_type,omitempty"`
	ValueString string      `protobuf:"bytes,3,opt,name=value_string,json=valueString" json:"value_string,omitempty"`
	ValueInt    int64       `protobuf:"varint,4,opt,name=value_int,json=valueInt" json:"value_int,omitempty"`
}

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

func (m *KVPair) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *KVPair) GetValueType() KVPair_Type {
	if m != nil {
		return m.ValueType
	}
	return KVPair_STRING
}

func (m *KVPair) GetValueString() string {
	if m != nil {
		return m.ValueString
	}
	return ""
}

func (m *KVPair) GetValueInt() int64 {
	if m != nil {
		return m.ValueInt
	}
	return 0
}

func init() {
	proto.RegisterType((*Request)(nil), "types.Request")
	proto.RegisterType((*RequestEcho)(nil), "types.RequestEcho")
	proto.RegisterType((*RequestFlush)(nil), "types.RequestFlush")
	proto.RegisterType((*RequestInfo)(nil), "types.RequestInfo")
	proto.RegisterType((*RequestSetOption)(nil), "types.RequestSetOption")
	proto.RegisterType((*RequestDeliverTx)(nil), "types.RequestDeliverTx")
	proto.RegisterType((*RequestCheckTx)(nil), "types.RequestCheckTx")
	proto.RegisterType((*RequestQuery)(nil), "types.RequestQuery")
	proto.RegisterType((*RequestCommit)(nil), "types.RequestCommit")
	proto.RegisterType((*RequestInitChain)(nil), "types.RequestInitChain")
	proto.RegisterType((*RequestBeginBlock)(nil), "types.RequestBeginBlock")
	proto.RegisterType((*RequestEndBlock)(nil), "types.RequestEndBlock")
	proto.RegisterType((*Response)(nil), "types.Response")
	proto.RegisterType((*ResponseException)(nil), "types.ResponseException")
	proto.RegisterType((*ResponseEcho)(nil), "types.ResponseEcho")
	proto.RegisterType((*ResponseFlush)(nil), "types.ResponseFlush")
	proto.RegisterType((*ResponseInfo)(nil), "types.ResponseInfo")
	proto.RegisterType((*ResponseSetOption)(nil), "types.ResponseSetOption")
	proto.RegisterType((*ResponseDeliverTx)(nil), "types.ResponseDeliverTx")
	proto.RegisterType((*ResponseCheckTx)(nil), "types.ResponseCheckTx")
	proto.RegisterType((*ResponseQuery)(nil), "types.ResponseQuery")
	proto.RegisterType((*ResponseCommit)(nil), "types.ResponseCommit")
	proto.RegisterType((*ResponseInitChain)(nil), "types.ResponseInitChain")
	proto.RegisterType((*ResponseBeginBlock)(nil), "types.ResponseBeginBlock")
	proto.RegisterType((*ResponseEndBlock)(nil), "types.ResponseEndBlock")
	proto.RegisterType((*Header)(nil), "types.Header")
	proto.RegisterType((*BlockID)(nil), "types.BlockID")
	proto.RegisterType((*PartSetHeader)(nil), "types.PartSetHeader")
	proto.RegisterType((*Validator)(nil), "types.Validator")
	proto.RegisterType((*KVPair)(nil), "types.KVPair")
	proto.RegisterEnum("types.KVPair_Type", KVPair_Type_name, KVPair_Type_value)
}

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

type ABCIApplicationClient interface {
	Echo(ctx context.Context, in *RequestEcho, opts ...grpc.CallOption) (*ResponseEcho, error)
	Flush(ctx context.Context, in *RequestFlush, opts ...grpc.CallOption) (*ResponseFlush, error)
	Info(ctx context.Context, in *RequestInfo, opts ...grpc.CallOption) (*ResponseInfo, error)
	SetOption(ctx context.Context, in *RequestSetOption, opts ...grpc.CallOption) (*ResponseSetOption, error)
	DeliverTx(ctx context.Context, in *RequestDeliverTx, opts ...grpc.CallOption) (*ResponseDeliverTx, error)
	CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error)
	Query(ctx context.Context, in *RequestQuery, opts ...grpc.CallOption) (*ResponseQuery, error)
	Commit(ctx context.Context, in *RequestCommit, opts ...grpc.CallOption) (*ResponseCommit, error)
	InitChain(ctx context.Context, in *RequestInitChain, opts ...grpc.CallOption) (*ResponseInitChain, error)
	BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error)
	EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error)
}

type aBCIApplicationClient struct {
	cc *grpc.ClientConn
}

func NewABCIApplicationClient(cc *grpc.ClientConn) ABCIApplicationClient {
	return &aBCIApplicationClient{cc}
}

func (c *aBCIApplicationClient) Echo(ctx context.Context, in *RequestEcho, opts ...grpc.CallOption) (*ResponseEcho, error) {
	out := new(ResponseEcho)
	err := grpc.Invoke(ctx, "/types.ABCIApplication/Echo", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aBCIApplicationClient) Flush(ctx context.Context, in *RequestFlush, opts ...grpc.CallOption) (*ResponseFlush, error) {
	out := new(ResponseFlush)
	err := grpc.Invoke(ctx, "/types.ABCIApplication/Flush", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aBCIApplicationClient) Info(ctx context.Context, in *RequestInfo, opts ...grpc.CallOption) (*ResponseInfo, error) {
	out := new(ResponseInfo)
	err := grpc.Invoke(ctx, "/types.ABCIApplication/Info", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aBCIApplicationClient) SetOption(ctx context.Context, in *RequestSetOption, opts ...grpc.CallOption) (*ResponseSetOption, error) {
	out := new(ResponseSetOption)
	err := grpc.Invoke(ctx, "/types.ABCIApplication/SetOption", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aBCIApplicationClient) DeliverTx(ctx context.Context, in *RequestDeliverTx, opts ...grpc.CallOption) (*ResponseDeliverTx, error) {
	out := new(ResponseDeliverTx)
	err := grpc.Invoke(ctx, "/types.ABCIApplication/DeliverTx", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aBCIApplicationClient) CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error) {
	out := new(ResponseCheckTx)
	err := grpc.Invoke(ctx, "/types.ABCIApplication/CheckTx", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aBCIApplicationClient) Query(ctx context.Context, in *RequestQuery, opts ...grpc.CallOption) (*ResponseQuery, error) {
	out := new(ResponseQuery)
	err := grpc.Invoke(ctx, "/types.ABCIApplication/Query", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aBCIApplicationClient) Commit(ctx context.Context, in *RequestCommit, opts ...grpc.CallOption) (*ResponseCommit, error) {
	out := new(ResponseCommit)
	err := grpc.Invoke(ctx, "/types.ABCIApplication/Commit", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aBCIApplicationClient) InitChain(ctx context.Context, in *RequestInitChain, opts ...grpc.CallOption) (*ResponseInitChain, error) {
	out := new(ResponseInitChain)
	err := grpc.Invoke(ctx, "/types.ABCIApplication/InitChain", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aBCIApplicationClient) BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error) {
	out := new(ResponseBeginBlock)
	err := grpc.Invoke(ctx, "/types.ABCIApplication/BeginBlock", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aBCIApplicationClient) EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error) {
	out := new(ResponseEndBlock)
	err := grpc.Invoke(ctx, "/types.ABCIApplication/EndBlock", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for ABCIApplication service

type ABCIApplicationServer interface {
	Echo(context.Context, *RequestEcho) (*ResponseEcho, error)
	Flush(context.Context, *RequestFlush) (*ResponseFlush, error)
	Info(context.Context, *RequestInfo) (*ResponseInfo, error)
	SetOption(context.Context, *RequestSetOption) (*ResponseSetOption, error)
	DeliverTx(context.Context, *RequestDeliverTx) (*ResponseDeliverTx, error)
	CheckTx(context.Context, *RequestCheckTx) (*ResponseCheckTx, error)
	Query(context.Context, *RequestQuery) (*ResponseQuery, error)
	Commit(context.Context, *RequestCommit) (*ResponseCommit, error)
	InitChain(context.Context, *RequestInitChain) (*ResponseInitChain, error)
	BeginBlock(context.Context, *RequestBeginBlock) (*ResponseBeginBlock, error)
	EndBlock(context.Context, *RequestEndBlock) (*ResponseEndBlock, error)
}

func RegisterABCIApplicationServer(s *grpc.Server, srv ABCIApplicationServer) {
	s.RegisterService(&_ABCIApplication_serviceDesc, srv)
}

func _ABCIApplication_Echo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestEcho)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ABCIApplicationServer).Echo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.ABCIApplication/Echo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ABCIApplicationServer).Echo(ctx, req.(*RequestEcho))
	}
	return interceptor(ctx, in, info, handler)
}

func _ABCIApplication_Flush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestFlush)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ABCIApplicationServer).Flush(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.ABCIApplication/Flush",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ABCIApplicationServer).Flush(ctx, req.(*RequestFlush))
	}
	return interceptor(ctx, in, info, handler)
}

func _ABCIApplication_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ABCIApplicationServer).Info(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.ABCIApplication/Info",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ABCIApplicationServer).Info(ctx, req.(*RequestInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _ABCIApplication_SetOption_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestSetOption)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ABCIApplicationServer).SetOption(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.ABCIApplication/SetOption",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ABCIApplicationServer).SetOption(ctx, req.(*RequestSetOption))
	}
	return interceptor(ctx, in, info, handler)
}

func _ABCIApplication_DeliverTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestDeliverTx)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ABCIApplicationServer).DeliverTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.ABCIApplication/DeliverTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ABCIApplicationServer).DeliverTx(ctx, req.(*RequestDeliverTx))
	}
	return interceptor(ctx, in, info, handler)
}

func _ABCIApplication_CheckTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestCheckTx)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ABCIApplicationServer).CheckTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.ABCIApplication/CheckTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ABCIApplicationServer).CheckTx(ctx, req.(*RequestCheckTx))
	}
	return interceptor(ctx, in, info, handler)
}

func _ABCIApplication_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ABCIApplicationServer).Query(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.ABCIApplication/Query",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ABCIApplicationServer).Query(ctx, req.(*RequestQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _ABCIApplication_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestCommit)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ABCIApplicationServer).Commit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.ABCIApplication/Commit",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ABCIApplicationServer).Commit(ctx, req.(*RequestCommit))
	}
	return interceptor(ctx, in, info, handler)
}

func _ABCIApplication_InitChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestInitChain)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ABCIApplicationServer).InitChain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.ABCIApplication/InitChain",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ABCIApplicationServer).InitChain(ctx, req.(*RequestInitChain))
	}
	return interceptor(ctx, in, info, handler)
}

func _ABCIApplication_BeginBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestBeginBlock)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ABCIApplicationServer).BeginBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.ABCIApplication/BeginBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ABCIApplicationServer).BeginBlock(ctx, req.(*RequestBeginBlock))
	}
	return interceptor(ctx, in, info, handler)
}

func _ABCIApplication_EndBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestEndBlock)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ABCIApplicationServer).EndBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.ABCIApplication/EndBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ABCIApplicationServer).EndBlock(ctx, req.(*RequestEndBlock))
	}
	return interceptor(ctx, in, info, handler)
}

var _ABCIApplication_serviceDesc = grpc.ServiceDesc{
	ServiceName: "types.ABCIApplication",
	HandlerType: (*ABCIApplicationServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Echo",
			Handler:    _ABCIApplication_Echo_Handler,
		},
		{
			MethodName: "Flush",
			Handler:    _ABCIApplication_Flush_Handler,
		},
		{
			MethodName: "Info",
			Handler:    _ABCIApplication_Info_Handler,
		},
		{
			MethodName: "SetOption",
			Handler:    _ABCIApplication_SetOption_Handler,
		},
		{
			MethodName: "DeliverTx",
			Handler:    _ABCIApplication_DeliverTx_Handler,
		},
		{
			MethodName: "CheckTx",
			Handler:    _ABCIApplication_CheckTx_Handler,
		},
		{
			MethodName: "Query",
			Handler:    _ABCIApplication_Query_Handler,
		},
		{
			MethodName: "Commit",
			Handler:    _ABCIApplication_Commit_Handler,
		},
		{
			MethodName: "InitChain",
			Handler:    _ABCIApplication_InitChain_Handler,
		},
		{
			MethodName: "BeginBlock",
			Handler:    _ABCIApplication_BeginBlock_Handler,
		},
		{
			MethodName: "EndBlock",
			Handler:    _ABCIApplication_EndBlock_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "types/types.proto",
}

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

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