tendermint/types/types.pb.go

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

/*
Package types is a generated protocol buffer package.

It is generated from these files:
	types.proto

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

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

// 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.
const _ = proto.ProtoPackageIsVersion1

// Not being used
// Could be added to request/response
// so we don't have to type switch
// (would be twice as fast, but we're talking about 15ns)
type MessageType int32

const (
	MessageType_NullMessage MessageType = 0
	MessageType_Echo        MessageType = 1
	MessageType_Flush       MessageType = 2
	MessageType_Info        MessageType = 3
	MessageType_SetOption   MessageType = 4
	MessageType_Exception   MessageType = 5
	MessageType_AppendTx    MessageType = 17
	MessageType_CheckTx     MessageType = 18
	MessageType_Commit      MessageType = 19
	MessageType_Query       MessageType = 20
	MessageType_InitChain   MessageType = 21
	MessageType_BeginBlock  MessageType = 22
	MessageType_EndBlock    MessageType = 23
)

var MessageType_name = map[int32]string{
	0:  "NullMessage",
	1:  "Echo",
	2:  "Flush",
	3:  "Info",
	4:  "SetOption",
	5:  "Exception",
	17: "AppendTx",
	18: "CheckTx",
	19: "Commit",
	20: "Query",
	21: "InitChain",
	22: "BeginBlock",
	23: "EndBlock",
}
var MessageType_value = map[string]int32{
	"NullMessage": 0,
	"Echo":        1,
	"Flush":       2,
	"Info":        3,
	"SetOption":   4,
	"Exception":   5,
	"AppendTx":    17,
	"CheckTx":     18,
	"Commit":      19,
	"Query":       20,
	"InitChain":   21,
	"BeginBlock":  22,
	"EndBlock":    23,
}

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

type CodeType int32

const (
	CodeType_OK CodeType = 0
	// General response codes, 0 ~ 99
	CodeType_InternalError     CodeType = 1
	CodeType_EncodingError     CodeType = 2
	CodeType_BadNonce          CodeType = 3
	CodeType_Unauthorized      CodeType = 4
	CodeType_InsufficientFunds CodeType = 5
	CodeType_UnknownRequest    CodeType = 6
	// Reserved for basecoin, 100 ~ 199
	CodeType_BaseDuplicateAddress     CodeType = 101
	CodeType_BaseEncodingError        CodeType = 102
	CodeType_BaseInsufficientFees     CodeType = 103
	CodeType_BaseInsufficientFunds    CodeType = 104
	CodeType_BaseInsufficientGasPrice CodeType = 105
	CodeType_BaseInvalidInput         CodeType = 106
	CodeType_BaseInvalidOutput        CodeType = 107
	CodeType_BaseInvalidPubKey        CodeType = 108
	CodeType_BaseInvalidSequence      CodeType = 109
	CodeType_BaseInvalidSignature     CodeType = 110
	CodeType_BaseUnknownAddress       CodeType = 111
	CodeType_BaseUnknownPubKey        CodeType = 112
	CodeType_BaseUnknownPlugin        CodeType = 113
	// Reserved for governance, 200 ~ 299
	CodeType_GovUnknownEntity      CodeType = 201
	CodeType_GovUnknownGroup       CodeType = 202
	CodeType_GovUnknownProposal    CodeType = 203
	CodeType_GovDuplicateGroup     CodeType = 204
	CodeType_GovDuplicateMember    CodeType = 205
	CodeType_GovDuplicateProposal  CodeType = 206
	CodeType_GovDuplicateVote      CodeType = 207
	CodeType_GovInvalidMember      CodeType = 208
	CodeType_GovInvalidVote        CodeType = 209
	CodeType_GovInvalidVotingPower CodeType = 210
)

var CodeType_name = map[int32]string{
	0:   "OK",
	1:   "InternalError",
	2:   "EncodingError",
	3:   "BadNonce",
	4:   "Unauthorized",
	5:   "InsufficientFunds",
	6:   "UnknownRequest",
	101: "BaseDuplicateAddress",
	102: "BaseEncodingError",
	103: "BaseInsufficientFees",
	104: "BaseInsufficientFunds",
	105: "BaseInsufficientGasPrice",
	106: "BaseInvalidInput",
	107: "BaseInvalidOutput",
	108: "BaseInvalidPubKey",
	109: "BaseInvalidSequence",
	110: "BaseInvalidSignature",
	111: "BaseUnknownAddress",
	112: "BaseUnknownPubKey",
	113: "BaseUnknownPlugin",
	201: "GovUnknownEntity",
	202: "GovUnknownGroup",
	203: "GovUnknownProposal",
	204: "GovDuplicateGroup",
	205: "GovDuplicateMember",
	206: "GovDuplicateProposal",
	207: "GovDuplicateVote",
	208: "GovInvalidMember",
	209: "GovInvalidVote",
	210: "GovInvalidVotingPower",
}
var CodeType_value = map[string]int32{
	"OK":                       0,
	"InternalError":            1,
	"EncodingError":            2,
	"BadNonce":                 3,
	"Unauthorized":             4,
	"InsufficientFunds":        5,
	"UnknownRequest":           6,
	"BaseDuplicateAddress":     101,
	"BaseEncodingError":        102,
	"BaseInsufficientFees":     103,
	"BaseInsufficientFunds":    104,
	"BaseInsufficientGasPrice": 105,
	"BaseInvalidInput":         106,
	"BaseInvalidOutput":        107,
	"BaseInvalidPubKey":        108,
	"BaseInvalidSequence":      109,
	"BaseInvalidSignature":     110,
	"BaseUnknownAddress":       111,
	"BaseUnknownPubKey":        112,
	"BaseUnknownPlugin":        113,
	"GovUnknownEntity":         201,
	"GovUnknownGroup":          202,
	"GovUnknownProposal":       203,
	"GovDuplicateGroup":        204,
	"GovDuplicateMember":       205,
	"GovDuplicateProposal":     206,
	"GovDuplicateVote":         207,
	"GovInvalidMember":         208,
	"GovInvalidVote":           209,
	"GovInvalidVotingPower":    210,
}

func (x CodeType) String() string {
	return proto.EnumName(CodeType_name, int32(x))
}
func (CodeType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

type Request struct {
	// Types that are valid to be assigned to Value:
	//	*Request_Echo
	//	*Request_Flush
	//	*Request_Info
	//	*Request_SetOption
	//	*Request_AppendTx
	//	*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_AppendTx struct {
	AppendTx *RequestAppendTx `protobuf:"bytes,5,opt,name=append_tx,json=appendTx,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_AppendTx) 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) GetAppendTx() *RequestAppendTx {
	if x, ok := m.GetValue().(*Request_AppendTx); ok {
		return x.AppendTx
	}
	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_AppendTx)(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_AppendTx:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.AppendTx); 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.append_tx
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RequestAppendTx)
		err := b.DecodeMessage(msg)
		m.Value = &Request_AppendTx{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_AppendTx:
		s := proto.Size(x.AppendTx)
		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} }

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

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

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

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

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

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

type RequestQuery struct {
	Query []byte `protobuf:"bytes,1,opt,name=query,proto3" json:"query,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} }

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 {
	Height uint64 `protobuf:"varint,1,opt,name=height" json:"height,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} }

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

type Response struct {
	// Types that are valid to be assigned to Value:
	//	*Response_Exception
	//	*Response_Echo
	//	*Response_Flush
	//	*Response_Info
	//	*Response_SetOption
	//	*Response_AppendTx
	//	*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_AppendTx struct {
	AppendTx *ResponseAppendTx `protobuf:"bytes,6,opt,name=append_tx,json=appendTx,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_AppendTx) 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) GetAppendTx() *ResponseAppendTx {
	if x, ok := m.GetValue().(*Response_AppendTx); ok {
		return x.AppendTx
	}
	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_AppendTx)(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_AppendTx:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.AppendTx); 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.append_tx
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseAppendTx)
		err := b.DecodeMessage(msg)
		m.Value = &Response_AppendTx{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_AppendTx:
		s := proto.Size(x.AppendTx)
		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} }

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

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 {
	Info string `protobuf:"bytes,1,opt,name=info" json:"info,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} }

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

type ResponseAppendTx struct {
	Code CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" 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 *ResponseAppendTx) Reset()                    { *m = ResponseAppendTx{} }
func (m *ResponseAppendTx) String() string            { return proto.CompactTextString(m) }
func (*ResponseAppendTx) ProtoMessage()               {}
func (*ResponseAppendTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }

type ResponseCheckTx struct {
	Code CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" 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 *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} }

type ResponseQuery struct {
	Code CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" 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 *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} }

type ResponseCommit struct {
	Code CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" 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} }

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,4,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 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{25} }

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((*RequestAppendTx)(nil), "types.RequestAppendTx")
	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((*ResponseAppendTx)(nil), "types.ResponseAppendTx")
	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((*Validator)(nil), "types.Validator")
	proto.RegisterEnum("types.MessageType", MessageType_name, MessageType_value)
	proto.RegisterEnum("types.CodeType", CodeType_name, CodeType_value)
}

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