certusone
/
tendermint
mirror of https://github.com/certusone/tendermint.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Use gogoproto's nullable=false (#166) 

* Use gogoproto's nullable=false where appropriate.
This commit is contained in:
Jae Kwon 2017-12-22 19:41:19 -08:00 committed by GitHub
parent e4b9f1abe7
commit aaaacba1cd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 174 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
example/dummy/dummy.go
View File

@ -39,7 +39,7 @@ func (app *DummyApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
} }
app.state.Set(key, value) app.state.Set(key, value)
tags := []*types.KVPair{ tags := []types.KVPair{
{Key: "app.creator", ValueType: types.KVPair_STRING, ValueString: "jae"}, {Key: "app.creator", ValueType: types.KVPair_STRING, ValueString: "jae"},
{Key: "app.key", ValueType: types.KVPair_STRING, ValueString: string(key)}, {Key: "app.key", ValueType: types.KVPair_STRING, ValueString: string(key)},
} }

18
example/dummy/dummy_test.go
View File

@ -92,7 +92,7 @@ func TestPersistentDummyInfo(t *testing.T) {
// make and apply block // make and apply block
height = int64(1) height = int64(1)
hash := []byte("foo") hash := []byte("foo")
header := &types.Header{ header := types.Header{
Height: int64(height), Height: int64(height),
} }
dummy.BeginBlock(types.RequestBeginBlock{hash, header, nil, nil}) dummy.BeginBlock(types.RequestBeginBlock{hash, header, nil, nil})
@ -124,11 +124,11 @@ func TestValUpdates(t *testing.T) {
vals1, vals2 := vals[:nInit], dummy.Validators() vals1, vals2 := vals[:nInit], dummy.Validators()
valsEqual(t, vals1, vals2) valsEqual(t, vals1, vals2)
var v1, v2, v3 *types.Validator var v1, v2, v3 types.Validator
// add some validators // add some validators
v1, v2 = vals[nInit], vals[nInit+1] v1, v2 = vals[nInit], vals[nInit+1]
diff := []*types.Validator{v1, v2} diff := []types.Validator{v1, v2}
tx1 := MakeValSetChangeTx(v1.PubKey, v1.Power) tx1 := MakeValSetChangeTx(v1.PubKey, v1.Power)
tx2 := MakeValSetChangeTx(v2.PubKey, v2.Power) tx2 := MakeValSetChangeTx(v2.PubKey, v2.Power)
@ -142,7 +142,7 @@ func TestValUpdates(t *testing.T) {
v1.Power = 0 v1.Power = 0
v2.Power = 0 v2.Power = 0
v3.Power = 0 v3.Power = 0
diff = []*types.Validator{v1, v2, v3} diff = []types.Validator{v1, v2, v3}
tx1 = MakeValSetChangeTx(v1.PubKey, v1.Power) tx1 = MakeValSetChangeTx(v1.PubKey, v1.Power)
tx2 = MakeValSetChangeTx(v2.PubKey, v2.Power) tx2 = MakeValSetChangeTx(v2.PubKey, v2.Power)
tx3 := MakeValSetChangeTx(v3.PubKey, v3.Power) tx3 := MakeValSetChangeTx(v3.PubKey, v3.Power)
@ -160,22 +160,22 @@ func TestValUpdates(t *testing.T) {
} else { } else {
v1.Power = 5 v1.Power = 5
} }
diff = []*types.Validator{v1} diff = []types.Validator{v1}
tx1 = MakeValSetChangeTx(v1.PubKey, v1.Power) tx1 = MakeValSetChangeTx(v1.PubKey, v1.Power)
makeApplyBlock(t, dummy, 3, diff, tx1) makeApplyBlock(t, dummy, 3, diff, tx1)
vals1 = append([]*types.Validator{v1}, vals1[1:]...) vals1 = append([]types.Validator{v1}, vals1[1:]...)
vals2 = dummy.Validators() vals2 = dummy.Validators()
valsEqual(t, vals1, vals2) valsEqual(t, vals1, vals2)
} }
func makeApplyBlock(t *testing.T, dummy types.Application, heightInt int, diff []*types.Validator, txs ...[]byte) { func makeApplyBlock(t *testing.T, dummy types.Application, heightInt int, diff []types.Validator, txs ...[]byte) {
// make and apply block // make and apply block
height := int64(heightInt) height := int64(heightInt)
hash := []byte("foo") hash := []byte("foo")
header := &types.Header{ header := types.Header{
Height: height, Height: height,
} }
@ -193,7 +193,7 @@ func makeApplyBlock(t *testing.T, dummy types.Application, heightInt int, diff [
} }
// order doesn't matter // order doesn't matter
func valsEqual(t *testing.T, vals1, vals2 []*types.Validator) { func valsEqual(t *testing.T, vals1, vals2 []types.Validator) {
if len(vals1) != len(vals2) { if len(vals1) != len(vals2) {
t.Fatalf("vals dont match in len. got %d, expected %d", len(vals2), len(vals1)) t.Fatalf("vals dont match in len. got %d, expected %d", len(vals2), len(vals1))
} }

8
example/dummy/helpers.go
View File

@ -8,18 +8,18 @@ import (
// RandVal creates one random validator, with a key derived // RandVal creates one random validator, with a key derived
// from the input value // from the input value
func RandVal(i int) *types.Validator { func RandVal(i int) types.Validator {
pubkey := crypto.GenPrivKeyEd25519FromSecret([]byte(cmn.Fmt("test%d", i))).PubKey().Bytes() pubkey := crypto.GenPrivKeyEd25519FromSecret([]byte(cmn.Fmt("test%d", i))).PubKey().Bytes()
power := cmn.RandUint16() + 1 power := cmn.RandUint16() + 1
return &types.Validator{pubkey, int64(power)} return types.Validator{pubkey, int64(power)}
} }
// RandVals returns a list of cnt validators for initializing // RandVals returns a list of cnt validators for initializing
// the application. Note that the keys are deterministically // the application. Note that the keys are deterministically
// derived from the index in the array, while the power is // derived from the index in the array, while the power is
// random (Change this if not desired) // random (Change this if not desired)
func RandVals(cnt int) []*types.Validator { func RandVals(cnt int) []types.Validator {
res := make([]*types.Validator, cnt) res := make([]types.Validator, cnt)
for i := 0; i < cnt; i++ { for i := 0; i < cnt; i++ {
res[i] = RandVal(i) res[i] = RandVal(i)
} }

14
example/dummy/persistent_dummy.go
View File

@ -28,7 +28,7 @@ type PersistentDummyApplication struct {
app *DummyApplication app *DummyApplication
// validator set // validator set
ValUpdates []*types.Validator ValUpdates []types.Validator
logger log.Logger logger log.Logger
} }
@ -119,7 +119,7 @@ func (app *PersistentDummyApplication) InitChain(req types.RequestInitChain) typ
// Track the block hash and header information // Track the block hash and header information
func (app *PersistentDummyApplication) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginBlock { func (app *PersistentDummyApplication) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginBlock {
// reset valset changes // reset valset changes
app.ValUpdates = make([]*types.Validator, 0) app.ValUpdates = make([]types.Validator, 0)
return types.ResponseBeginBlock{} return types.ResponseBeginBlock{}
} }
@ -131,7 +131,7 @@ func (app *PersistentDummyApplication) EndBlock(req types.RequestEndBlock) types
//--------------------------------------------- //---------------------------------------------
// update validators // update validators
func (app *PersistentDummyApplication) Validators() (validators []*types.Validator) { func (app *PersistentDummyApplication) Validators() (validators []types.Validator) {
app.app.state.Iterate(func(key, value []byte) bool { app.app.state.Iterate(func(key, value []byte) bool {
if isValidatorTx(key) { if isValidatorTx(key) {
validator := new(types.Validator) validator := new(types.Validator)
@ -139,7 +139,7 @@ func (app *PersistentDummyApplication) Validators() (validators []*types.Validat
if err != nil { if err != nil {
panic(err) panic(err)
} }
validators = append(validators, validator) validators = append(validators, *validator)
} }
return false return false
}) })
@ -190,11 +190,11 @@ func (app *PersistentDummyApplication) execValidatorTx(tx []byte) types.Response
} }
// update // update
return app.updateValidator(&types.Validator{pubkey, power}) return app.updateValidator(types.Validator{pubkey, power})
} }
// add, update, or remove a validator // add, update, or remove a validator
func (app *PersistentDummyApplication) updateValidator(v *types.Validator) types.ResponseDeliverTx { func (app *PersistentDummyApplication) updateValidator(v types.Validator) types.ResponseDeliverTx {
key := []byte("val:" + string(v.PubKey)) key := []byte("val:" + string(v.PubKey))
if v.Power == 0 { if v.Power == 0 {
// remove validator // remove validator
@ -207,7 +207,7 @@ func (app *PersistentDummyApplication) updateValidator(v *types.Validator) types
} else { } else {
// add or update validator // add or update validator
value := bytes.NewBuffer(make([]byte, 0)) value := bytes.NewBuffer(make([]byte, 0))
if err := types.WriteMessage(v, value); err != nil { if err := types.WriteMessage(&v, value); err != nil {
return types.ResponseDeliverTx{ return types.ResponseDeliverTx{
Code: code.CodeTypeEncodingError, Code: code.CodeTypeEncodingError,
Log: fmt.Sprintf("Error encoding validator: %v", err)} Log: fmt.Sprintf("Error encoding validator: %v", err)}

4
tests/server/client.go
View File

@ -13,11 +13,11 @@ import (
func InitChain(client abcicli.Client) error { func InitChain(client abcicli.Client) error {
total := 10 total := 10
vals := make([]*types.Validator, total) vals := make([]types.Validator, total)
for i := 0; i < total; i++ { for i := 0; i < total; i++ {
pubkey := crypto.GenPrivKeyEd25519FromSecret([]byte(cmn.Fmt("test%d", i))).PubKey().Bytes() pubkey := crypto.GenPrivKeyEd25519FromSecret([]byte(cmn.Fmt("test%d", i))).PubKey().Bytes()
power := cmn.RandInt() power := cmn.RandInt()
vals[i] = &types.Validator{pubkey, int64(power)} vals[i] = types.Validator{pubkey, int64(power)}
} }
_, err := client.InitChainSync(types.RequestInitChain{Validators: vals}) _, err := client.InitChainSync(types.RequestInitChain{Validators: vals})
if err != nil { if err != nil {

257
types/types.pb.go
View File

@ -554,7 +554,7 @@ func (m *RequestSetOption) GetValue() string {
} }
type RequestInitChain struct { type RequestInitChain struct {
Validators []*Validator `protobuf:"bytes,1,rep,name=validators" json:"validators,omitempty"` Validators []Validator `protobuf:"bytes,1,rep,name=validators" json:"validators"`
} }
func (m *RequestInitChain) Reset() { *m = RequestInitChain{} } func (m *RequestInitChain) Reset() { *m = RequestInitChain{} }
@ -562,7 +562,7 @@ func (m *RequestInitChain) String() string { return proto.CompactText
func (*RequestInitChain) ProtoMessage() {} func (*RequestInitChain) ProtoMessage() {}
func (*RequestInitChain) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{5} } func (*RequestInitChain) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{5} }
func (m *RequestInitChain) GetValidators() []*Validator { func (m *RequestInitChain) GetValidators() []Validator {
if m != nil { if m != nil {
return m.Validators return m.Validators
} }
@ -611,9 +611,9 @@ func (m *RequestQuery) GetProve() bool {
type RequestBeginBlock struct { type RequestBeginBlock struct {
Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
Header *Header `protobuf:"bytes,2,opt,name=header" json:"header,omitempty"` Header Header `protobuf:"bytes,2,opt,name=header" json:"header"`
AbsentValidators []int32 `protobuf:"varint,3,rep,packed,name=absent_validators,json=absentValidators" json:"absent_validators,omitempty"` AbsentValidators []int32 `protobuf:"varint,3,rep,packed,name=absent_validators,json=absentValidators" json:"absent_validators,omitempty"`
ByzantineValidators []*Evidence `protobuf:"bytes,4,rep,name=byzantine_validators,json=byzantineValidators" json:"byzantine_validators,omitempty"` ByzantineValidators []Evidence `protobuf:"bytes,4,rep,name=byzantine_validators,json=byzantineValidators" json:"byzantine_validators"`
} }
func (m *RequestBeginBlock) Reset() { *m = RequestBeginBlock{} } func (m *RequestBeginBlock) Reset() { *m = RequestBeginBlock{} }
@ -628,11 +628,11 @@ func (m *RequestBeginBlock) GetHash() []byte {
return nil return nil
} }
func (m *RequestBeginBlock) GetHeader() *Header { func (m *RequestBeginBlock) GetHeader() Header {
if m != nil { if m != nil {
return m.Header return m.Header
} }
return nil return Header{}
} }
func (m *RequestBeginBlock) GetAbsentValidators() []int32 { func (m *RequestBeginBlock) GetAbsentValidators() []int32 {
@ -642,7 +642,7 @@ func (m *RequestBeginBlock) GetAbsentValidators() []int32 {
return nil return nil
} }
func (m *RequestBeginBlock) GetByzantineValidators() []*Evidence { func (m *RequestBeginBlock) GetByzantineValidators() []Evidence {
if m != nil { if m != nil {
return m.ByzantineValidators return m.ByzantineValidators
} }
@ -1344,7 +1344,7 @@ type ResponseDeliverTx struct {
Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
Data github_com_tendermint_go_wire_data.Bytes `protobuf:"bytes,2,opt,name=data,proto3,customtype=github.com/tendermint/go-wire/data.Bytes" json:"data"` Data github_com_tendermint_go_wire_data.Bytes `protobuf:"bytes,2,opt,name=data,proto3,customtype=github.com/tendermint/go-wire/data.Bytes" json:"data"`
Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
Tags []*KVPair `protobuf:"bytes,4,rep,name=tags" json:"tags,omitempty"` Tags []KVPair `protobuf:"bytes,4,rep,name=tags" json:"tags"`
} }
func (m *ResponseDeliverTx) Reset() { *m = ResponseDeliverTx{} } func (m *ResponseDeliverTx) Reset() { *m = ResponseDeliverTx{} }
@ -1366,7 +1366,7 @@ func (m *ResponseDeliverTx) GetLog() string {
return "" return ""
} }
func (m *ResponseDeliverTx) GetTags() []*KVPair { func (m *ResponseDeliverTx) GetTags() []KVPair {
if m != nil { if m != nil {
return m.Tags return m.Tags
} }
@ -1374,7 +1374,7 @@ func (m *ResponseDeliverTx) GetTags() []*KVPair {
} }
type ResponseEndBlock struct { type ResponseEndBlock struct {
ValidatorUpdates []*Validator `protobuf:"bytes,1,rep,name=validator_updates,json=validatorUpdates" json:"validator_updates,omitempty"` ValidatorUpdates []Validator `protobuf:"bytes,1,rep,name=validator_updates,json=validatorUpdates" json:"validator_updates"`
ConsensusParamUpdates *ConsensusParams `protobuf:"bytes,2,opt,name=consensus_param_updates,json=consensusParamUpdates" json:"consensus_param_updates,omitempty"` ConsensusParamUpdates *ConsensusParams `protobuf:"bytes,2,opt,name=consensus_param_updates,json=consensusParamUpdates" json:"consensus_param_updates,omitempty"`
} }
@ -1383,7 +1383,7 @@ func (m *ResponseEndBlock) String() string { return proto.CompactText
func (*ResponseEndBlock) ProtoMessage() {} func (*ResponseEndBlock) ProtoMessage() {}
func (*ResponseEndBlock) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{23} } func (*ResponseEndBlock) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{23} }
func (m *ResponseEndBlock) GetValidatorUpdates() []*Validator { func (m *ResponseEndBlock) GetValidatorUpdates() []Validator {
if m != nil { if m != nil {
return m.ValidatorUpdates return m.ValidatorUpdates
} }
@ -1538,7 +1538,7 @@ type Header struct {
Height int64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` Height int64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
Time int64 `protobuf:"varint,3,opt,name=time,proto3" json:"time,omitempty"` Time int64 `protobuf:"varint,3,opt,name=time,proto3" json:"time,omitempty"`
NumTxs int32 `protobuf:"varint,4,opt,name=num_txs,json=numTxs,proto3" json:"num_txs,omitempty"` NumTxs int32 `protobuf:"varint,4,opt,name=num_txs,json=numTxs,proto3" json:"num_txs,omitempty"`
LastBlockID *BlockID `protobuf:"bytes,5,opt,name=last_block_id,json=lastBlockId" json:"last_block_id,omitempty"` LastBlockID BlockID `protobuf:"bytes,5,opt,name=last_block_id,json=lastBlockId" json:"last_block_id"`
LastCommitHash []byte `protobuf:"bytes,6,opt,name=last_commit_hash,json=lastCommitHash,proto3" json:"last_commit_hash,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"` 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"` ValidatorsHash []byte `protobuf:"bytes,8,opt,name=validators_hash,json=validatorsHash,proto3" json:"validators_hash,omitempty"`
@ -1578,11 +1578,11 @@ func (m *Header) GetNumTxs() int32 {
return 0 return 0
} }
func (m *Header) GetLastBlockID() *BlockID { func (m *Header) GetLastBlockID() BlockID {
if m != nil { if m != nil {
return m.LastBlockID return m.LastBlockID
} }
return nil return BlockID{}
} }
func (m *Header) GetLastCommitHash() []byte { func (m *Header) GetLastCommitHash() []byte {
@ -1615,7 +1615,7 @@ func (m *Header) GetAppHash() []byte {
type BlockID struct { type BlockID struct {
Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
Parts *PartSetHeader `protobuf:"bytes,2,opt,name=parts" json:"parts,omitempty"` Parts PartSetHeader `protobuf:"bytes,2,opt,name=parts" json:"parts"`
} }
func (m *BlockID) Reset() { *m = BlockID{} } func (m *BlockID) Reset() { *m = BlockID{} }
@ -1630,11 +1630,11 @@ func (m *BlockID) GetHash() []byte {
return nil return nil
} }
func (m *BlockID) GetParts() *PartSetHeader { func (m *BlockID) GetParts() PartSetHeader {
if m != nil { if m != nil {
return m.Parts return m.Parts
} }
return nil return PartSetHeader{}
} }
type PartSetHeader struct { type PartSetHeader struct {
@ -2193,116 +2193,117 @@ var _ABCIApplication_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("types/types.proto", fileDescriptorTypes) } func init() { proto.RegisterFile("types/types.proto", fileDescriptorTypes) }
var fileDescriptorTypes = []byte{ var fileDescriptorTypes = []byte{
// 1766 bytes of a gzipped FileDescriptorProto // 1778 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x72, 0x1b, 0xc7, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x72, 0x1b, 0xc7,
0x11, 0x26, 0xfe, 0xb1, 0x0d, 0xfe, 0x80, 0x43, 0x4a, 0x82, 0xa1, 0x83, 0xe8, 0xad, 0x8a, 0x0d, 0x11, 0x26, 0xfe, 0xb1, 0x0d, 0xfe, 0x0e, 0x29, 0x09, 0x86, 0x0e, 0x62, 0xf6, 0x60, 0x41, 0x91,
0xd9, 0x16, 0x69, 0xd3, 0xa5, 0x94, 0x68, 0x27, 0xae, 0x08, 0xa4, 0x2c, 0xa2, 0x9c, 0x52, 0x94, 0x45, 0xda, 0x74, 0xc9, 0x25, 0xda, 0x29, 0x57, 0x04, 0x52, 0x16, 0x10, 0xa7, 0x64, 0x65, 0xc5,
0x15, 0xe3, 0x43, 0x2e, 0xa8, 0x01, 0x76, 0x08, 0x6c, 0x09, 0xd8, 0x5d, 0xef, 0x0e, 0x68, 0x50, 0xf8, 0x90, 0x0b, 0x6a, 0x80, 0x1d, 0x02, 0x5b, 0x02, 0x76, 0xd7, 0xbb, 0x03, 0x1a, 0x54, 0xe5,
0x95, 0x47, 0xf0, 0x3d, 0xe7, 0xe4, 0x98, 0x17, 0xc8, 0x31, 0xa7, 0xa4, 0xf2, 0x0c, 0x39, 0xe8, 0x11, 0x7c, 0xcf, 0x39, 0xa7, 0xa4, 0xf2, 0x02, 0x79, 0x83, 0x54, 0x52, 0x79, 0x83, 0x1c, 0x78,
0xe0, 0x27, 0x49, 0x75, 0xcf, 0xec, 0x2f, 0x76, 0x53, 0x29, 0x1d, 0x74, 0x01, 0x66, 0xa6, 0x7f, 0xf0, 0x93, 0xa4, 0xba, 0x67, 0xf6, 0x97, 0xbb, 0x89, 0x4b, 0x07, 0x5f, 0x80, 0x99, 0xe9, 0x9f,
0xb6, 0xbb, 0xa7, 0xe7, 0xeb, 0x9e, 0x81, 0x7d, 0x79, 0xeb, 0x8b, 0xf0, 0x84, 0x7e, 0x8f, 0xfd, 0xed, 0xee, 0xe9, 0xf9, 0xba, 0x67, 0x60, 0x4f, 0x5e, 0xfb, 0x22, 0x3c, 0xa6, 0xdf, 0x23, 0x3f,
0xc0, 0x93, 0x1e, 0x6b, 0xd0, 0xa4, 0xff, 0x68, 0xe6, 0xc8, 0xf9, 0x6a, 0x72, 0x3c, 0xf5, 0x96, 0xf0, 0xa4, 0xc7, 0x1a, 0x34, 0xe9, 0x3d, 0x99, 0x39, 0x72, 0xbe, 0x9a, 0x1c, 0x4d, 0xbd, 0xe5,
0x27, 0x33, 0x6f, 0xe6, 0x9d, 0x10, 0x75, 0xb2, 0xba, 0xa6, 0x19, 0x4d, 0x68, 0xa4, 0xa4, 0xcc, 0xf1, 0xcc, 0x9b, 0x79, 0xc7, 0x44, 0x9d, 0xac, 0x2e, 0x69, 0x46, 0x13, 0x1a, 0x29, 0x29, 0xf3,
0x7f, 0xd5, 0xa1, 0x65, 0x89, 0x1f, 0x56, 0x22, 0x94, 0x6c, 0x00, 0x75, 0x31, 0x9d, 0x7b, 0xbd, 0x1f, 0x75, 0x68, 0x59, 0xe2, 0xbb, 0x95, 0x08, 0x25, 0xeb, 0x43, 0x5d, 0x4c, 0xe7, 0x5e, 0xb7,
0xea, 0x51, 0x65, 0xd0, 0x39, 0x65, 0xc7, 0x4a, 0xbb, 0xa6, 0x3e, 0x9b, 0xce, 0xbd, 0xcb, 0x2d, 0x7a, 0x58, 0xe9, 0x77, 0x4e, 0xd8, 0x91, 0xd2, 0xae, 0xa9, 0x2f, 0xa6, 0x73, 0x6f, 0xb8, 0x61,
0x8b, 0x38, 0xd8, 0xa7, 0xd0, 0xb8, 0x5e, 0xac, 0xc2, 0x79, 0xaf, 0x46, 0xac, 0x07, 0x59, 0xd6, 0x11, 0x07, 0x7b, 0x0c, 0x8d, 0xcb, 0xc5, 0x2a, 0x9c, 0x77, 0x6b, 0xc4, 0xba, 0x9f, 0x65, 0xfd,
0x6f, 0x91, 0x74, 0xb9, 0x65, 0x29, 0x1e, 0x54, 0xeb, 0xb8, 0xd7, 0x5e, 0xaf, 0x5e, 0xa4, 0x76, 0x0a, 0x49, 0xc3, 0x0d, 0x4b, 0xf1, 0xa0, 0x5a, 0xc7, 0xbd, 0xf4, 0xba, 0xf5, 0x22, 0xb5, 0x23,
0xe4, 0x5e, 0x93, 0x5a, 0xe4, 0x60, 0x4f, 0x00, 0x42, 0x21, 0xc7, 0x9e, 0x2f, 0x1d, 0xcf, 0xed, 0xf7, 0x92, 0xd4, 0x22, 0x07, 0x7b, 0x06, 0x10, 0x0a, 0x39, 0xf6, 0x7c, 0xe9, 0x78, 0x6e, 0xb7,
0x35, 0x88, 0xff, 0x5e, 0x96, 0xff, 0x95, 0x90, 0xbf, 0x23, 0xf2, 0xe5, 0x96, 0x65, 0x84, 0xd1, 0x41, 0xfc, 0xf7, 0xb2, 0xfc, 0x6f, 0x84, 0xfc, 0x86, 0xc8, 0xc3, 0x0d, 0xcb, 0x08, 0xa3, 0x09,
0x04, 0x25, 0x1d, 0xd7, 0x91, 0xe3, 0xe9, 0x9c, 0x3b, 0x6e, 0xaf, 0x59, 0x24, 0x39, 0x72, 0x1d, 0x4a, 0x3a, 0xae, 0x23, 0xc7, 0xd3, 0x39, 0x77, 0xdc, 0x6e, 0xb3, 0x48, 0x72, 0xe4, 0x3a, 0xf2,
0x79, 0x8e, 0x64, 0x94, 0x74, 0xa2, 0x09, 0xba, 0xf2, 0xc3, 0x4a, 0x04, 0xb7, 0xbd, 0x56, 0x91, 0x0c, 0xc9, 0x28, 0xe9, 0x44, 0x13, 0x74, 0xe5, 0xbb, 0x95, 0x08, 0xae, 0xbb, 0xad, 0x22, 0x57,
0x2b, 0xbf, 0x47, 0x12, 0xba, 0x42, 0x3c, 0xec, 0x6b, 0xe8, 0x4c, 0xc4, 0xcc, 0x71, 0xc7, 0x93, 0x7e, 0x87, 0x24, 0x74, 0x85, 0x78, 0xd8, 0x17, 0xd0, 0x99, 0x88, 0x99, 0xe3, 0x8e, 0x27, 0x0b,
0x85, 0x37, 0x7d, 0xdd, 0x6b, 0x93, 0x48, 0x2f, 0x2b, 0x32, 0x44, 0x86, 0x21, 0xd2, 0x2f, 0xb7, 0x6f, 0xfa, 0xb6, 0xdb, 0x26, 0x91, 0x6e, 0x56, 0x64, 0x80, 0x0c, 0x03, 0xa4, 0x0f, 0x37, 0x2c,
0x2c, 0x98, 0xc4, 0x33, 0x76, 0x0a, 0xed, 0xe9, 0x5c, 0x4c, 0x5f, 0x8f, 0xe5, 0xba, 0x67, 0x90, 0x98, 0xc4, 0x33, 0x76, 0x02, 0xed, 0xe9, 0x5c, 0x4c, 0xdf, 0x8e, 0xe5, 0xba, 0x6b, 0x90, 0xe4,
0xe4, 0x9d, 0xac, 0xe4, 0x39, 0x52, 0xaf, 0xd6, 0x97, 0x5b, 0x56, 0x6b, 0xaa, 0x86, 0xe8, 0x97, 0x9d, 0xac, 0xe4, 0x19, 0x52, 0x2f, 0xd6, 0xc3, 0x0d, 0xab, 0x35, 0x55, 0x43, 0xf4, 0xcb, 0x16,
0x2d, 0x16, 0xce, 0x8d, 0x08, 0x50, 0xea, 0xa0, 0xc8, 0xaf, 0x0b, 0x45, 0x27, 0x39, 0xc3, 0x8e, 0x0b, 0xe7, 0x4a, 0x04, 0x28, 0xb5, 0x5f, 0xe4, 0xd7, 0xb9, 0xa2, 0x93, 0x9c, 0x61, 0x47, 0x13,
0x26, 0xec, 0x31, 0x18, 0xc2, 0xb5, 0xb5, 0xa1, 0x1d, 0x12, 0xbc, 0x9b, 0xdb, 0x51, 0xd7, 0x8e, 0xf6, 0x14, 0x0c, 0xe1, 0xda, 0xda, 0xd0, 0x0e, 0x09, 0xde, 0xcd, 0xed, 0xa8, 0x6b, 0x47, 0x66,
0xcc, 0x6c, 0x0b, 0x3d, 0x66, 0xc7, 0xd0, 0x9c, 0x7a, 0xcb, 0xa5, 0x23, 0x7b, 0xdb, 0x24, 0x73, 0xb6, 0x85, 0x1e, 0xb3, 0x23, 0x68, 0x4e, 0xbd, 0xe5, 0xd2, 0x91, 0xdd, 0x4d, 0x92, 0x39, 0xc8,
0x98, 0x33, 0x91, 0x68, 0x97, 0x5b, 0x96, 0xe6, 0x1a, 0xb6, 0xa0, 0x71, 0xc3, 0x17, 0x2b, 0x61, 0x99, 0x48, 0xb4, 0xe1, 0x86, 0xa5, 0xb9, 0x06, 0x2d, 0x68, 0x5c, 0xf1, 0xc5, 0x4a, 0x98, 0x0f,
0x7e, 0x0c, 0x9d, 0x54, 0xa6, 0xb0, 0x1e, 0xb4, 0x96, 0x22, 0x0c, 0xf9, 0x4c, 0xf4, 0x2a, 0x47, 0xa1, 0x93, 0xca, 0x14, 0xd6, 0x85, 0xd6, 0x52, 0x84, 0x21, 0x9f, 0x89, 0x6e, 0xe5, 0xb0, 0xd2,
0x95, 0x81, 0x61, 0x45, 0x53, 0x73, 0x17, 0xb6, 0xd3, 0x79, 0x92, 0x12, 0xc4, 0x5c, 0x40, 0xc1, 0x37, 0xac, 0x68, 0x6a, 0x6e, 0xc3, 0x66, 0x3a, 0x4f, 0x52, 0x82, 0x98, 0x0b, 0x28, 0x78, 0x25,
0x1b, 0x11, 0x84, 0x98, 0x00, 0x5a, 0x50, 0x4f, 0xcd, 0xaf, 0xa0, 0x9b, 0x4f, 0x02, 0xd6, 0x85, 0x82, 0x10, 0x13, 0x40, 0x0b, 0xea, 0xa9, 0xf9, 0x39, 0xec, 0xe6, 0x93, 0x80, 0xed, 0x42, 0xed,
0xda, 0x6b, 0x71, 0xab, 0x39, 0x71, 0xc8, 0x0e, 0xb5, 0x41, 0x94, 0xc5, 0x86, 0xa5, 0xad, 0xbb, 0xad, 0xb8, 0xd6, 0x9c, 0x38, 0x64, 0x07, 0xda, 0x20, 0xca, 0x62, 0xc3, 0xd2, 0xd6, 0xfd, 0x26,
0x88, 0x65, 0xe3, 0x34, 0x60, 0x9f, 0x03, 0xdc, 0xf0, 0x85, 0x63, 0x73, 0xe9, 0x05, 0x61, 0xaf, 0x96, 0x8d, 0xd3, 0x80, 0x7d, 0x06, 0x70, 0xc5, 0x17, 0x8e, 0xcd, 0xa5, 0x17, 0x84, 0xdd, 0xca,
0x72, 0x54, 0x1b, 0x74, 0x4e, 0xbb, 0xda, 0xdd, 0xef, 0x23, 0x82, 0x95, 0xe2, 0x31, 0xed, 0xd8, 0x61, 0xad, 0xdf, 0x39, 0xd9, 0xd5, 0xee, 0x7e, 0x1b, 0x11, 0x06, 0xf5, 0x7f, 0xde, 0x3c, 0xd8,
0x74, 0xca, 0x0b, 0xc6, 0xa0, 0x6e, 0x73, 0xc9, 0xe9, 0xf3, 0xdb, 0x16, 0x8d, 0x71, 0xcd, 0xe7, 0xb0, 0x52, 0x9c, 0xa6, 0x1d, 0x3b, 0x40, 0xd9, 0xc1, 0x18, 0xd4, 0x6d, 0x2e, 0x39, 0x19, 0xb1,
0x72, 0xae, 0x3f, 0x4f, 0x63, 0x76, 0x17, 0x9a, 0x73, 0xe1, 0xcc, 0xe6, 0x92, 0xce, 0x4b, 0xcd, 0x69, 0xd1, 0x18, 0xd7, 0x7c, 0x2e, 0xe7, 0xda, 0x08, 0x1a, 0xb3, 0xbb, 0xd0, 0x9c, 0x0b, 0x67,
0xd2, 0x33, 0xb4, 0xd5, 0x0f, 0xbc, 0x1b, 0x41, 0x47, 0xa3, 0x6d, 0xa9, 0x89, 0xf9, 0x8f, 0x0a, 0x36, 0x97, 0x74, 0x6a, 0x6a, 0x96, 0x9e, 0xa1, 0xc5, 0x7e, 0xe0, 0x5d, 0x09, 0x3a, 0x20, 0x6d,
0xec, 0x6f, 0xe4, 0x12, 0xea, 0x9d, 0xf3, 0x70, 0x1e, 0x7d, 0x0b, 0xc7, 0xec, 0x17, 0xa8, 0x97, 0x4b, 0x4d, 0xcc, 0x7f, 0x57, 0x60, 0xef, 0x56, 0x46, 0xa1, 0xde, 0x39, 0x0f, 0xe7, 0xd1, 0xb7,
0xdb, 0x22, 0xd0, 0x47, 0x76, 0x47, 0x5b, 0x7f, 0x49, 0x8b, 0x96, 0x26, 0xb2, 0x4f, 0x61, 0x9f, 0x70, 0xcc, 0x1e, 0xa3, 0x5e, 0x6e, 0x8b, 0x40, 0x1f, 0xdc, 0x2d, 0xed, 0xc3, 0x90, 0x16, 0xb5,
0x4f, 0x42, 0xe1, 0xca, 0x71, 0xca, 0xdf, 0xda, 0x51, 0x6d, 0xd0, 0xb0, 0xba, 0x8a, 0x10, 0xbb, 0x03, 0x9a, 0x85, 0x3d, 0x86, 0x3d, 0x3e, 0x09, 0x85, 0x2b, 0xc7, 0x29, 0xdf, 0x6b, 0x87, 0xb5,
0x1b, 0xb2, 0x21, 0x1c, 0x4e, 0x6e, 0xdf, 0x70, 0x57, 0x3a, 0xae, 0x48, 0xf3, 0xd7, 0x29, 0x3e, 0x7e, 0xc3, 0xda, 0x55, 0x84, 0xd8, 0xf5, 0x90, 0x0d, 0xe1, 0x60, 0x72, 0xfd, 0x8e, 0xbb, 0xd2,
0x7b, 0xfa, 0x0b, 0xcf, 0x6e, 0x1c, 0x5b, 0xb8, 0x53, 0x61, 0x1d, 0xc4, 0xcc, 0x89, 0x0e, 0xf3, 0x71, 0x45, 0x9a, 0xbf, 0x4e, 0xb1, 0xda, 0xd1, 0xdf, 0x79, 0x71, 0xe5, 0xd8, 0xc2, 0x9d, 0x0a,
0x08, 0x76, 0xb3, 0x29, 0xcd, 0x76, 0xa1, 0x2a, 0xd7, 0xda, 0xf6, 0xaa, 0x5c, 0x9b, 0x66, 0xbc, 0xfd, 0xa5, 0xfd, 0x58, 0x24, 0xd1, 0x64, 0x1e, 0xc2, 0x76, 0x36, 0xc9, 0xd9, 0x36, 0x54, 0xe5,
0x1f, 0x71, 0xfa, 0x6e, 0xf0, 0x3c, 0x84, 0xbd, 0x5c, 0xa6, 0xa6, 0x02, 0x59, 0x49, 0x07, 0xd2, 0x5a, 0xfb, 0x51, 0x95, 0x6b, 0xd3, 0x8c, 0x77, 0x28, 0x4e, 0xe8, 0x5b, 0x3c, 0x8f, 0x60, 0x27,
0xdc, 0x83, 0x9d, 0x4c, 0x82, 0x9a, 0x3f, 0x35, 0xa0, 0x6d, 0x89, 0xd0, 0xf7, 0xdc, 0x50, 0xb0, 0x97, 0xbb, 0xa9, 0xa0, 0x56, 0xd2, 0x41, 0x35, 0x77, 0x60, 0x2b, 0x93, 0xb2, 0xe6, 0x0f, 0x0d,
0x27, 0x60, 0x88, 0xf5, 0x54, 0x28, 0x54, 0xa9, 0xe4, 0xce, 0xac, 0xe2, 0x79, 0x16, 0xd1, 0xf1, 0x68, 0x5b, 0x22, 0xf4, 0x3d, 0x37, 0x14, 0xec, 0x19, 0x18, 0x62, 0x3d, 0x15, 0x0a, 0x67, 0x2a,
0x10, 0xc5, 0xcc, 0xec, 0x61, 0x06, 0x11, 0x0f, 0xf2, 0x42, 0x69, 0x48, 0xfc, 0x2c, 0x0b, 0x89, 0xb9, 0x53, 0xac, 0x78, 0x5e, 0x44, 0x74, 0x3c, 0x56, 0x31, 0x33, 0x7b, 0x94, 0xc1, 0xc8, 0xfd,
0x87, 0x39, 0xde, 0x1c, 0x26, 0x3e, 0xcc, 0x60, 0x62, 0x5e, 0x71, 0x06, 0x14, 0xcf, 0x0a, 0x40, 0xbc, 0x50, 0x1a, 0x24, 0x3f, 0xca, 0x82, 0xe4, 0x41, 0x8e, 0x37, 0x87, 0x92, 0x8f, 0x32, 0x28,
0x31, 0x6f, 0x7e, 0x09, 0x2a, 0x9e, 0x15, 0xa0, 0x62, 0x6f, 0xe3, 0x5b, 0x85, 0xb0, 0xf8, 0x59, 0x99, 0x57, 0x9c, 0x81, 0xc9, 0xd3, 0x02, 0x98, 0xcc, 0x9b, 0x5f, 0x82, 0x93, 0xa7, 0x05, 0x38,
0x16, 0x16, 0xf3, 0xee, 0xe4, 0x70, 0xf1, 0x57, 0x45, 0xb8, 0xf8, 0x41, 0x4e, 0xa6, 0x14, 0x18, 0xd9, 0xbd, 0xf5, 0xad, 0x42, 0xa0, 0xfc, 0x28, 0x0b, 0x94, 0x79, 0x77, 0x72, 0x48, 0xf9, 0xab,
0xbf, 0xdc, 0x00, 0xc6, 0xbb, 0x39, 0xd1, 0x02, 0x64, 0x3c, 0xcb, 0x20, 0x23, 0x14, 0xfa, 0x56, 0x22, 0xa4, 0xfc, 0x20, 0x27, 0x53, 0x0a, 0x95, 0x9f, 0xde, 0x82, 0xca, 0xbb, 0x39, 0xd1, 0x02,
0x02, 0x8d, 0xbf, 0xdc, 0x84, 0xc6, 0x7b, 0xf9, 0xad, 0x2d, 0xc2, 0xc6, 0x93, 0x1c, 0x36, 0xde, 0xac, 0x3c, 0xcd, 0x60, 0x25, 0x14, 0xfa, 0x56, 0x02, 0x96, 0x9f, 0xdd, 0x06, 0xcb, 0x7b, 0xf9,
0xc9, 0x5b, 0x59, 0x0a, 0x8e, 0x0f, 0xf1, 0x44, 0xe7, 0x32, 0x0d, 0x4f, 0xbf, 0x08, 0x02, 0x2f, 0xad, 0x2d, 0x42, 0xcb, 0xe3, 0x1c, 0x5a, 0xde, 0xc9, 0x5b, 0x59, 0x0a, 0x97, 0x8f, 0xf0, 0x74,
0xd0, 0xe8, 0xa5, 0x26, 0xe6, 0x00, 0x31, 0x26, 0xc9, 0xaf, 0xff, 0x01, 0xa4, 0x94, 0xf4, 0xa9, 0xe7, 0x32, 0x0d, 0x91, 0x40, 0x04, 0x81, 0x17, 0x68, 0x3c, 0x53, 0x13, 0xb3, 0x8f, 0x78, 0x93,
0xec, 0x32, 0xff, 0x5c, 0x49, 0x64, 0x09, 0x4b, 0xd3, 0xf8, 0x64, 0x68, 0x7c, 0x4a, 0xe1, 0x6b, 0xe4, 0xd7, 0xff, 0x80, 0x56, 0x4a, 0xfa, 0x54, 0x76, 0x99, 0x7f, 0xaa, 0x24, 0xb2, 0x84, 0xae,
0x35, 0x83, 0xaf, 0xec, 0x13, 0xd8, 0x5f, 0xf0, 0x50, 0xaa, 0xb8, 0x8c, 0x33, 0x80, 0xb5, 0x87, 0x69, 0xac, 0x32, 0x34, 0x56, 0xa5, 0x10, 0xb7, 0x9a, 0x41, 0x5c, 0xf6, 0x4b, 0xd8, 0x5b, 0xf0,
0x04, 0x15, 0x10, 0x85, 0x5c, 0x8f, 0xe0, 0x20, 0xc5, 0xcb, 0x7d, 0x7f, 0x4c, 0xe0, 0x54, 0xa7, 0x50, 0xaa, 0xb8, 0x8c, 0x33, 0xe0, 0xb5, 0x83, 0x04, 0x15, 0x10, 0x85, 0x62, 0x4f, 0x60, 0x3f,
0xc3, 0xdb, 0x8d, 0xb9, 0x9f, 0xfa, 0xfe, 0x25, 0x0f, 0xe7, 0xe6, 0x59, 0xe2, 0x7f, 0x82, 0xdd, 0xc5, 0xcb, 0x7d, 0x7f, 0x4c, 0x40, 0x55, 0xa7, 0xc3, 0xbb, 0x1b, 0x73, 0x3f, 0xf7, 0xfd, 0x21,
0x0c, 0xea, 0x53, 0xcf, 0x56, 0x6e, 0xed, 0x58, 0x34, 0x46, 0x3c, 0x5f, 0x78, 0x33, 0x6d, 0x19, 0x0f, 0xe7, 0xe6, 0x69, 0xe2, 0x7f, 0x82, 0xe6, 0x0c, 0xea, 0x53, 0xcf, 0x56, 0x6e, 0x6d, 0x59,
0x0e, 0xcd, 0x83, 0x44, 0x34, 0x4e, 0x55, 0xf3, 0xef, 0xd5, 0xc4, 0xf7, 0x18, 0x8a, 0x37, 0x94, 0x34, 0x46, 0x84, 0x5f, 0x78, 0x33, 0x6d, 0x19, 0x0e, 0xcd, 0xfd, 0x44, 0x34, 0x4e, 0x55, 0xf3,
0x1d, 0x42, 0xc3, 0x71, 0x6d, 0xb1, 0x26, 0x75, 0x35, 0x4b, 0x4d, 0xd8, 0x50, 0x95, 0x0c, 0x74, 0xef, 0xd5, 0xc4, 0xf7, 0x18, 0x96, 0x6f, 0x29, 0x3b, 0x80, 0x86, 0xe3, 0xda, 0x62, 0x4d, 0xea,
0x6c, 0x7b, 0xf8, 0xf9, 0xbf, 0xdf, 0x3e, 0xd8, 0xfa, 0xcf, 0xdb, 0x07, 0x83, 0x54, 0xd7, 0x24, 0x6a, 0x96, 0x9a, 0xb0, 0x81, 0x2a, 0x22, 0xe8, 0xd8, 0xe6, 0xe0, 0x63, 0x04, 0xb1, 0xff, 0xdc,
0x85, 0x6b, 0x8b, 0x60, 0xe9, 0xb8, 0xf2, 0x64, 0xe6, 0x3d, 0xfa, 0xd1, 0x09, 0xc4, 0x09, 0x46, 0x3c, 0xe8, 0xa7, 0xfa, 0x28, 0x29, 0x5c, 0x5b, 0x04, 0x4b, 0xc7, 0x95, 0xc7, 0x33, 0xef, 0xc9,
0xee, 0x78, 0x78, 0x2b, 0x45, 0xa8, 0x8a, 0xcc, 0xb7, 0x51, 0x91, 0xa9, 0xbf, 0xa3, 0x16, 0x25, 0xf7, 0x4e, 0x20, 0x8e, 0x31, 0x72, 0x47, 0x83, 0x6b, 0x29, 0x42, 0x55, 0x76, 0xbe, 0x8a, 0xca,
0x8e, 0x7a, 0xfc, 0xc0, 0xf3, 0xae, 0xe9, 0x58, 0xbf, 0x93, 0x1e, 0x12, 0x4f, 0xe1, 0x62, 0x33, 0x4e, 0xfd, 0x3d, 0xb5, 0x28, 0x71, 0xd4, 0xe3, 0x07, 0x9e, 0x77, 0x49, 0xc7, 0xfa, 0xbd, 0xf4,
0x53, 0x60, 0x74, 0x38, 0x5b, 0x49, 0x38, 0x0f, 0x81, 0x6d, 0x9e, 0x47, 0xf3, 0x2f, 0x15, 0xc4, 0x90, 0x78, 0x0a, 0x17, 0x9b, 0x99, 0x62, 0xa3, 0xc3, 0xd9, 0x4a, 0xc2, 0x79, 0x00, 0xec, 0xf6,
0xda, 0xcc, 0x59, 0x2b, 0x8c, 0xe8, 0x85, 0x4e, 0xa8, 0xea, 0x3b, 0x9a, 0xab, 0x52, 0x50, 0x5b, 0x79, 0x34, 0xff, 0x5c, 0x41, 0xac, 0xcd, 0x9c, 0xb5, 0xc2, 0x88, 0x9e, 0xeb, 0x84, 0xaa, 0xbe,
0x55, 0x8b, 0xad, 0xc2, 0x95, 0x19, 0x0f, 0x29, 0x9a, 0x35, 0x0b, 0x87, 0xb8, 0x72, 0x2d, 0x04, 0xa7, 0xb9, 0x2a, 0x05, 0xb5, 0x55, 0xb5, 0xd8, 0x2a, 0x5c, 0x99, 0xf1, 0x90, 0xa2, 0x59, 0xb3,
0xc5, 0xa5, 0x66, 0xe1, 0xd0, 0xfc, 0x6b, 0x25, 0xc9, 0x84, 0xa4, 0x68, 0xbc, 0x4f, 0x2b, 0x3f, 0x70, 0x88, 0x2b, 0x97, 0x42, 0x50, 0x5c, 0x6a, 0x16, 0x0e, 0xcd, 0xbf, 0x56, 0x92, 0x4c, 0x48,
0x84, 0xba, 0xe4, 0xb3, 0xa8, 0x14, 0x46, 0xc5, 0xf6, 0xbb, 0xef, 0x5f, 0x72, 0x27, 0xb0, 0x88, 0x8a, 0xc6, 0xcf, 0x69, 0xe5, 0x43, 0xa8, 0x4b, 0x3e, 0x8b, 0x0a, 0x62, 0x54, 0x78, 0xbf, 0xfe,
0x84, 0x81, 0xec, 0xe6, 0x31, 0x84, 0xfd, 0x1a, 0xf6, 0xe3, 0x42, 0x3a, 0x5e, 0xf9, 0x36, 0x97, 0xf6, 0x35, 0x77, 0xa2, 0xc2, 0x4b, 0x0c, 0xe6, 0x5f, 0x2a, 0x58, 0xde, 0xb2, 0x48, 0xc2, 0xce,
0xa2, 0xbc, 0xdf, 0xe8, 0xc6, 0xac, 0x7f, 0x50, 0x9c, 0xec, 0x05, 0xdc, 0x9b, 0xa2, 0x3e, 0x37, 0x60, 0x2f, 0x2e, 0xaa, 0xe3, 0x95, 0x6f, 0x73, 0x29, 0xfe, 0x5f, 0x1f, 0xb2, 0x1b, 0x0b, 0xfc,
0x5c, 0x85, 0x63, 0x9f, 0x07, 0x7c, 0x19, 0x2b, 0xa9, 0x66, 0xd0, 0xf2, 0x3c, 0xe2, 0x7a, 0x89, 0x5e, 0xf1, 0xb3, 0x57, 0x70, 0x6f, 0x8a, 0x5a, 0xdd, 0x70, 0x15, 0x8e, 0x7d, 0x1e, 0xf0, 0x65,
0x4c, 0xa1, 0x75, 0x67, 0x9a, 0x59, 0xd0, 0xfa, 0xcc, 0x3f, 0x61, 0x75, 0x4e, 0x23, 0xd6, 0xfb, 0xac, 0xaa, 0x9a, 0x41, 0xce, 0xb3, 0x88, 0xeb, 0x35, 0x32, 0x85, 0xd6, 0x9d, 0x69, 0x66, 0x41,
0x0c, 0x22, 0xa5, 0x5a, 0xce, 0x50, 0x76, 0x02, 0xa0, 0x80, 0x24, 0x74, 0xde, 0x08, 0x5d, 0xa1, 0xeb, 0x33, 0xff, 0x88, 0x95, 0x3a, 0x8d, 0x5e, 0x3f, 0x67, 0x40, 0x29, 0xed, 0x72, 0x86, 0xb2,
0xa3, 0xc8, 0x50, 0x08, 0x5f, 0x39, 0x6f, 0x84, 0x65, 0x4c, 0xa2, 0x21, 0xfb, 0x08, 0x5a, 0x72, 0x63, 0x00, 0x05, 0x2a, 0xa1, 0xf3, 0x4e, 0xe8, 0x6a, 0x1d, 0xc5, 0x87, 0x02, 0xf9, 0xc6, 0x79,
0xad, 0xb8, 0xb3, 0x9d, 0xcf, 0xd5, 0x9a, 0x58, 0x9b, 0x92, 0xfe, 0xd9, 0x63, 0xd8, 0x56, 0x8a, 0x27, 0x2c, 0x63, 0x12, 0x0d, 0xd9, 0x87, 0xd0, 0x92, 0x6b, 0xc5, 0x9d, 0xed, 0x88, 0x2e, 0xd6,
0x67, 0x5e, 0x18, 0x3a, 0xbe, 0xae, 0xcd, 0x2c, 0xad, 0xfa, 0x39, 0x51, 0xac, 0xce, 0x24, 0x99, 0xc4, 0xda, 0x94, 0xf4, 0xcf, 0x9e, 0xc2, 0xa6, 0x52, 0x3c, 0xf3, 0xc2, 0xd0, 0xf1, 0x75, 0x9d,
0x98, 0x7f, 0x04, 0x23, 0xfe, 0x2c, 0xbb, 0x0f, 0xc6, 0x92, 0xaf, 0xc7, 0x93, 0x5b, 0xb5, 0x6b, 0x66, 0x69, 0xd5, 0x2f, 0x89, 0x62, 0x75, 0x26, 0xc9, 0xc4, 0xfc, 0x03, 0x18, 0xf1, 0x67, 0xd9,
0x95, 0x41, 0xc3, 0x6a, 0x2f, 0xf9, 0x9a, 0xbc, 0x64, 0xf7, 0xa0, 0x85, 0x44, 0xb9, 0x56, 0x7b, 0x7d, 0x30, 0x96, 0x7c, 0x3d, 0x9e, 0x5c, 0xab, 0xbd, 0xab, 0xf4, 0x1b, 0x56, 0x7b, 0xc9, 0xd7,
0xd1, 0xb0, 0x9a, 0x4b, 0xbe, 0xbe, 0x5a, 0xc7, 0x04, 0xcc, 0x6a, 0xdd, 0xf3, 0x2d, 0xf9, 0xfa, 0xe4, 0x25, 0xbb, 0x07, 0x2d, 0x24, 0xca, 0xb5, 0xda, 0x8b, 0x86, 0xd5, 0x5c, 0xf2, 0xf5, 0xc5,
0x39, 0x0f, 0xcd, 0x6f, 0xa0, 0xa9, 0x8c, 0xfc, 0xbf, 0x14, 0xa3, 0x7c, 0x35, 0x23, 0xff, 0x1b, 0x3a, 0x26, 0x60, 0x86, 0xeb, 0x5e, 0x70, 0xc9, 0xd7, 0x2f, 0x79, 0x68, 0x7e, 0x09, 0x4d, 0x65,
0xe8, 0xa4, 0xec, 0x66, 0x5f, 0xc0, 0x1d, 0xe5, 0xa1, 0xcf, 0x03, 0x49, 0x11, 0xc9, 0x28, 0x64, 0xe4, 0x4f, 0x52, 0x8c, 0xf2, 0xd5, 0x8c, 0xfc, 0xaf, 0xa1, 0x93, 0xb2, 0x9b, 0x7d, 0x02, 0x77,
0x44, 0x7c, 0xc9, 0x03, 0x89, 0x9f, 0x24, 0xd5, 0xe6, 0x3f, 0xab, 0xd0, 0x54, 0x1d, 0x22, 0xfb, 0x94, 0x87, 0x3e, 0x0f, 0x24, 0x45, 0x24, 0xa3, 0x90, 0x11, 0xf1, 0x35, 0x0f, 0x24, 0x7e, 0x92,
0x08, 0x2b, 0x2f, 0x77, 0xdc, 0xb1, 0x63, 0xab, 0x22, 0x31, 0xec, 0xfc, 0xfc, 0xf6, 0x41, 0x8b, 0x54, 0x9b, 0xff, 0xaa, 0x42, 0x53, 0x75, 0x8e, 0xec, 0x43, 0xac, 0xc2, 0xdc, 0x71, 0xc7, 0x8e,
0x40, 0x76, 0x74, 0x81, 0xc5, 0x16, 0x07, 0x76, 0x0a, 0x5f, 0xaa, 0x19, 0x7c, 0x61, 0x50, 0x97, 0xad, 0x0a, 0xc6, 0xa0, 0xf3, 0xe3, 0xcd, 0x83, 0x16, 0x01, 0xee, 0xe8, 0x1c, 0x0b, 0x2f, 0x0e,
0xce, 0x52, 0x68, 0x17, 0x69, 0x8c, 0x96, 0xbb, 0xab, 0x25, 0x85, 0xa4, 0xae, 0x42, 0xe2, 0xae, 0xec, 0x14, 0xd6, 0x54, 0x33, 0x58, 0xc3, 0xa0, 0x2e, 0x9d, 0xa5, 0xd0, 0x2e, 0xd2, 0x18, 0x2d,
0x96, 0x18, 0x92, 0x73, 0xd8, 0x49, 0xd5, 0x0c, 0xc7, 0xd6, 0xbd, 0xcc, 0x6e, 0x7a, 0x37, 0x46, 0x77, 0x57, 0x4b, 0x0a, 0x49, 0x5d, 0x85, 0xc4, 0x5d, 0x2d, 0x31, 0x24, 0x2f, 0x61, 0x2b, 0x55,
0x17, 0xc3, 0xbd, 0x9f, 0xdf, 0x3e, 0xe8, 0xfc, 0x36, 0xaa, 0x20, 0xa3, 0x0b, 0xab, 0x13, 0x97, 0x3f, 0x1c, 0x5b, 0xf7, 0x35, 0xdb, 0xe9, 0xdd, 0x18, 0x9d, 0x0f, 0xf6, 0x31, 0xd5, 0x7e, 0xbc,
0x93, 0x91, 0xcd, 0x06, 0x40, 0xd5, 0x65, 0xac, 0x2a, 0xac, 0xaa, 0x3a, 0x4d, 0xaa, 0x3a, 0xbb, 0x79, 0xd0, 0xf9, 0x6d, 0x54, 0x51, 0x46, 0xe7, 0x56, 0x27, 0x2e, 0x2f, 0x23, 0x9b, 0xf5, 0x81,
0xb8, 0xae, 0x4b, 0x30, 0x36, 0xc7, 0xf7, 0xc1, 0xc0, 0x14, 0x54, 0x2c, 0x2d, 0x62, 0x69, 0xe3, 0xaa, 0xcd, 0x58, 0x55, 0x5c, 0x55, 0x85, 0x9a, 0x54, 0x85, 0xb6, 0x71, 0x5d, 0x97, 0x64, 0x6c,
0x02, 0x11, 0x3f, 0x86, 0xbd, 0xa4, 0xb7, 0x55, 0x2c, 0x6d, 0xa5, 0x25, 0x59, 0x26, 0xc6, 0x0f, 0x9c, 0xef, 0x83, 0x81, 0x69, 0xa8, 0x58, 0x5a, 0xc4, 0xd2, 0xc6, 0x05, 0x22, 0x3e, 0x84, 0x9d,
0xa0, 0x1d, 0x57, 0x37, 0x83, 0x38, 0x5a, 0x5c, 0x17, 0xb5, 0x11, 0xb4, 0xb4, 0x89, 0x85, 0xcd, 0xa4, 0xe3, 0x55, 0x2c, 0x6d, 0xa5, 0x25, 0x59, 0x26, 0xc6, 0x0f, 0xa0, 0x1d, 0x57, 0x3b, 0x83,
0xf9, 0x27, 0xd0, 0xc0, 0x3d, 0x89, 0x0e, 0x69, 0xd4, 0x41, 0xd1, 0x5e, 0x08, 0xa9, 0x5b, 0x74, 0x38, 0x5a, 0x5c, 0x17, 0xb9, 0x6f, 0xa0, 0xa5, 0x4d, 0x2c, 0x6c, 0xdc, 0x3f, 0x86, 0x06, 0xee,
0xc5, 0x62, 0x9e, 0xc1, 0x4e, 0x66, 0x1d, 0x4b, 0x97, 0xf4, 0x24, 0x5f, 0xe8, 0x6d, 0x54, 0x93, 0x4b, 0x74, 0x50, 0xa3, 0x8e, 0x8a, 0xf6, 0x43, 0xc8, 0x4c, 0xfb, 0xae, 0x18, 0xcd, 0x53, 0xd8,
0xf8, 0x33, 0xd5, 0xe4, 0x33, 0xe6, 0x57, 0x60, 0xc4, 0xe0, 0x81, 0xb1, 0xf7, 0x57, 0x93, 0x71, 0xca, 0x50, 0xb1, 0xa0, 0x49, 0x4f, 0xf2, 0x85, 0xde, 0x50, 0x35, 0x89, 0x3f, 0x56, 0x4d, 0x3e,
0x74, 0x25, 0xda, 0xb6, 0x9a, 0xfe, 0x6a, 0xf2, 0x9d, 0xba, 0x15, 0xf9, 0xde, 0x8f, 0xfa, 0xa2, 0x66, 0x7e, 0x0e, 0x46, 0x0c, 0x26, 0xb8, 0x0b, 0xfe, 0x6a, 0x32, 0x8e, 0xae, 0x4e, 0x9b, 0x56,
0x50, 0xb3, 0xd4, 0xc4, 0xfc, 0x1a, 0xda, 0x51, 0x23, 0x5f, 0x2e, 0x5a, 0xb2, 0xf7, 0xe6, 0xdf, 0xd3, 0x5f, 0x4d, 0xbe, 0x56, 0xb7, 0x27, 0xdf, 0xfb, 0x5e, 0x5f, 0x25, 0x6a, 0x96, 0x9a, 0x98,
0x2a, 0xd0, 0x54, 0xd8, 0x57, 0x70, 0x0b, 0xfb, 0x82, 0xee, 0x56, 0x2b, 0x31, 0x46, 0xa7, 0x49, 0x5f, 0x40, 0x3b, 0x6a, 0xf2, 0xcb, 0x45, 0x4b, 0xb2, 0xc0, 0xfc, 0x5b, 0x05, 0x9a, 0x0a, 0x11,
0x70, 0x37, 0x3e, 0x76, 0x4a, 0xe8, 0xf8, 0xea, 0xd6, 0x17, 0x96, 0x41, 0x5c, 0x38, 0x64, 0x1f, 0x0b, 0x6e, 0x6b, 0x9f, 0xd0, 0x1d, 0x6c, 0x25, 0xc6, 0xe8, 0x3a, 0x09, 0x6e, 0xc7, 0x07, 0x50,
0xc2, 0xb6, 0x12, 0x09, 0x65, 0xe0, 0xb8, 0x11, 0x66, 0x74, 0x68, 0xed, 0x15, 0x2d, 0xe1, 0x96, 0x09, 0x1d, 0x5d, 0x5c, 0xfb, 0xc2, 0x32, 0x88, 0x0b, 0x87, 0xec, 0x17, 0xb0, 0xa9, 0x44, 0x42,
0x2a, 0x16, 0xc7, 0x95, 0xba, 0x58, 0xb4, 0x69, 0x61, 0xe4, 0x4a, 0xf3, 0x3e, 0xd4, 0x49, 0x0f, 0x19, 0x38, 0x6e, 0x84, 0x1e, 0x1d, 0x5a, 0x7b, 0x43, 0x4b, 0xb8, 0xb1, 0x8a, 0xc5, 0x71, 0xa5,
0x40, 0xf3, 0xd5, 0x95, 0x35, 0x7a, 0xf1, 0xbc, 0xbb, 0xc5, 0x5a, 0x50, 0x1b, 0xbd, 0xb8, 0xea, 0x2e, 0x21, 0x6d, 0x5a, 0x18, 0xb9, 0xd2, 0xbc, 0x0f, 0x75, 0xd2, 0x03, 0xd0, 0x7c, 0x73, 0x61,
0x56, 0x4e, 0x7f, 0x6a, 0xc0, 0xde, 0xd3, 0xe1, 0xf9, 0xe8, 0xa9, 0xef, 0x2f, 0x9c, 0x29, 0xa7, 0x8d, 0x5e, 0xbd, 0xdc, 0xdd, 0x60, 0x2d, 0xa8, 0x8d, 0x5e, 0x5d, 0xec, 0x56, 0x4e, 0x7e, 0x68,
0xfe, 0xe3, 0x04, 0xea, 0xd4, 0x61, 0x15, 0x3c, 0x74, 0xf4, 0x8b, 0x5a, 0x7d, 0x76, 0x0a, 0x0d, 0xc0, 0xce, 0xf3, 0xc1, 0xd9, 0xe8, 0xb9, 0xef, 0x2f, 0x9c, 0x29, 0xa7, 0xae, 0xe4, 0x18, 0xea,
0x6a, 0xb4, 0x58, 0xd1, 0x7b, 0x47, 0xbf, 0xb0, 0xe3, 0xc7, 0x8f, 0xa8, 0x56, 0x6c, 0xf3, 0xd9, 0xd4, 0x77, 0x15, 0x3c, 0x88, 0xf4, 0x8a, 0x2e, 0x00, 0xec, 0x04, 0x1a, 0xd4, 0x7e, 0xb1, 0xa2,
0xa3, 0x5f, 0xd4, 0xf6, 0xb3, 0x6f, 0xc0, 0x48, 0x5a, 0xa4, 0xb2, 0xc7, 0x8f, 0x7e, 0xe9, 0x05, 0x77, 0x91, 0x5e, 0xe1, 0x3d, 0x00, 0x3f, 0xa2, 0x1a, 0xb4, 0xdb, 0xcf, 0x23, 0xbd, 0xa2, 0xcb,
0x00, 0xe5, 0x93, 0xea, 0x58, 0xf6, 0x54, 0xd0, 0x2f, 0xed, 0x94, 0xd9, 0x13, 0x68, 0x45, 0x1d, 0x00, 0xfb, 0x12, 0x8c, 0xa4, 0x71, 0x2a, 0x7b, 0x24, 0xe9, 0x95, 0x5e, 0x0b, 0x50, 0x3e, 0xa9,
0x40, 0xf1, 0xf3, 0x44, 0xbf, 0xa4, 0x39, 0xc7, 0xf0, 0xa8, 0x5e, 0xac, 0xe8, 0x0d, 0xa5, 0x5f, 0x99, 0x65, 0x4f, 0x0a, 0xbd, 0xd2, 0xfe, 0x99, 0x3d, 0x83, 0x56, 0xd4, 0x17, 0x14, 0x3f, 0x63,
0x78, 0x83, 0x60, 0x8f, 0xa1, 0xa9, 0x6b, 0x50, 0xe1, 0x43, 0x43, 0xbf, 0xb8, 0xc5, 0x46, 0x27, 0xf4, 0x4a, 0x5a, 0x76, 0x0c, 0x8f, 0xea, 0xd0, 0x8a, 0xde, 0x5a, 0x7a, 0x85, 0xf7, 0x0a, 0xf6,
0x93, 0x7b, 0x7c, 0xd9, 0x3b, 0x4f, 0xbf, 0xf4, 0xaa, 0xc3, 0x9e, 0x02, 0xa4, 0xae, 0xd6, 0xa5, 0x14, 0x9a, 0xba, 0x1a, 0x15, 0x3e, 0x48, 0xf4, 0x8a, 0x1b, 0x6f, 0x74, 0x32, 0xb9, 0xef, 0x97,
0x0f, 0x38, 0xfd, 0xf2, 0x2b, 0x0c, 0xc3, 0xb3, 0x13, 0x5f, 0x4b, 0x8b, 0x1f, 0x56, 0xfa, 0x65, 0xbd, 0x07, 0xf5, 0x4a, 0x2f, 0x40, 0xec, 0x39, 0x40, 0xea, 0xf2, 0x5d, 0xfa, 0xd0, 0xd3, 0x2b,
0xb7, 0x8a, 0x49, 0x93, 0x1e, 0xdf, 0xbe, 0xfc, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7b, 0xb9, 0xbf, 0xd8, 0x30, 0x3c, 0x3b, 0xf1, 0x65, 0xb5, 0xf8, 0x01, 0xa6, 0x57, 0x76, 0xd7, 0x98, 0x34,
0xeb, 0x12, 0xc7, 0x13, 0x00, 0x00, 0xe9, 0x91, 0xee, 0xd3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xe7, 0x2c, 0x50, 0x08, 0xef, 0x13,
0x00, 0x00,
} }

14
types/types.proto
View File

@ -43,7 +43,7 @@ message RequestSetOption {
} }
message RequestInitChain { message RequestInitChain {
repeated Validator validators = 1; repeated Validator validators = 1 [(gogoproto.nullable) = false];
} }
message RequestQuery { message RequestQuery {
@ -55,9 +55,9 @@ message RequestQuery{
message RequestBeginBlock { message RequestBeginBlock {
bytes hash = 1; bytes hash = 1;
Header header = 2; Header header = 2 [(gogoproto.nullable) = false];
repeated int32 absent_validators = 3; repeated int32 absent_validators = 3;
repeated Evidence byzantine_validators = 4; repeated Evidence byzantine_validators = 4 [(gogoproto.nullable) = false];
} }
message RequestCheckTx { message RequestCheckTx {
@ -146,11 +146,11 @@ message ResponseDeliverTx {
uint32 code = 1; uint32 code = 1;
bytes data = 2 [(gogoproto.customtype) = "github.com/tendermint/go-wire/data.Bytes", (gogoproto.nullable) = false]; bytes data = 2 [(gogoproto.customtype) = "github.com/tendermint/go-wire/data.Bytes", (gogoproto.nullable) = false];
string log = 3; string log = 3;
repeated KVPair tags = 4; repeated KVPair tags = 4 [(gogoproto.nullable) = false];
} }
message ResponseEndBlock { message ResponseEndBlock {
repeated Validator validator_updates = 1; repeated Validator validator_updates = 1 [(gogoproto.nullable) = false];
ConsensusParams consensus_param_updates = 2; ConsensusParams consensus_param_updates = 2;
} }
@ -199,7 +199,7 @@ message Header {
int64 height = 2; int64 height = 2;
int64 time = 3; int64 time = 3;
int32 num_txs = 4; int32 num_txs = 4;
BlockID last_block_id = 5 [(gogoproto.customname) = "LastBlockID"]; BlockID last_block_id = 5 [(gogoproto.customname) = "LastBlockID", (gogoproto.nullable) = false];
bytes last_commit_hash = 6; bytes last_commit_hash = 6;
bytes data_hash = 7; bytes data_hash = 7;
bytes validators_hash = 8; bytes validators_hash = 8;
@ -208,7 +208,7 @@ message Header {
message BlockID { message BlockID {
bytes hash = 1; bytes hash = 1;
PartSetHeader parts = 2; PartSetHeader parts = 2 [(gogoproto.nullable) = false];
} }
message PartSetHeader { message PartSetHeader {

2
types/util.go
View File

@ -11,7 +11,7 @@ import (
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Validators is a list of validators that implements the Sort interface // Validators is a list of validators that implements the Sort interface
type Validators []*Validator type Validators []Validator
func (v Validators) Len() int { func (v Validators) Len() int {
return len(v) return len(v)